home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / xswsrv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-07  |  75.5 KB  |  3,413 lines
  1. /*
  2.  *    @(#) xswsrv.c 12.1 95/07/05 SCOINC
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S005, 02-Feb-94, rickra
  22.  *     Commented out DBD_LSTFILE from mem stuff. Seems like it is
  23.  *     no longer in 32V5..
  24.  *
  25.  * S004, 23-Oct-93, rickra
  26.  *     Added os_identity function.
  27.  *     Also added 32v4 Vs. 32v5 streams
  28.  *
  29.  * S003, 27-May-93, rickra
  30.  *     Added disk space gathering... 
  31.  *     Changed the uid-to-name to use tselect binary tree......
  32.  *
  33.  * S002, 27-May-93, rickra
  34.  *     Added security support.
  35.  *     Added NMOUNTS 
  36.  *     Added CALLOUTS 
  37.  *     Made utmp gathering dynamic....
  38.  *     Only read utmp file if it has been changed/modified.
  39.  *
  40.  *
  41.  * S001, 01-Jan-93, rickra
  42.  *     Fixed bug in cblocks where it was using current_v_proc instead
  43.  *         if using current_v_region....
  44.  * S000, 30-Sep-92, rickra
  45.  *     Added copyright and modification history
  46.  *    Added support for specify a different booted kernel, other thatn
  47.  *        /unix.
  48.  *    Added support to be sure that the kernel matches /dev/kmem
  49.  */
  50. /***************************************************************************
  51.  
  52. xswsrv.c
  53.  
  54. This program was written to interface with Xsw, a X application that
  55. does performance measurements.
  56.  
  57. *****************************************************************************/
  58.  
  59. #include "include/unixincs.h"
  60. #include "include/xswboth.h"
  61. #include "include/xswclient.h"
  62. #include "include/xswnlist.h"
  63. #include "include/nfsstat.h"
  64. #include "include/sync.h"
  65. #include <signal.h>
  66. #include <sys/callo.h>
  67. #include <sys/pfdat.h>
  68. #include <sys/mount.h>
  69. #include <sys/stat.h>
  70. #include <sys/statfs.h>
  71. #include <mnttab.h>
  72. #include <search.h>
  73.  
  74.  
  75. extern int      errno;
  76. extern char    *optarg;
  77. extern char    *defread ();
  78. extern int      defopen ();
  79.  
  80. int             alarm_state = 0;
  81.  
  82. int             FileDescriptor;    /* Value returned from "socket()" */
  83. int             count, BytesRecv;
  84. int             TotalPackets = -1;
  85. int             Flags, FromLen;
  86. struct sockaddr_in SocketID;    /* Used to get remote socket info */
  87. struct sockaddr From;
  88. struct servent *ServiceNum;
  89.  
  90. struct stat     current_mnt_stat;
  91. struct stat     mnt_stat;
  92. int             current_mnt_entries = 0;
  93. int             first_mnt_stat = 1;
  94.  
  95. char           *kernel = "/unix";
  96.  
  97. /*
  98. FILE           *tty_debug;
  99. */
  100.  
  101. #define DEFAULT "/etc/default/xswsrv"
  102. struct utsname  client_sysuts;
  103.  
  104. static char    *client_str = NULL;
  105. static int      found_client = 0;
  106.  
  107.  
  108. #define min(a,b) (((a) > (b)) ? (b) : (a))
  109. #define MTBUFSIZ        BUFSIZ
  110.  
  111. int             UTMPS_NUM = 5;
  112.  
  113. int             nutmps = 0;
  114. int             utmps_size = 10;
  115. struct utmp    *utmps;
  116. struct stat     utmp_stat;
  117. struct stat     utmp_stat_old;
  118.  
  119. char           *utmp_file = "/etc/utmp";
  120.  
  121. int             current_v_proc = 0;
  122. int             current_v_file = 0;
  123. int             current_v_inode = 0;
  124. int             current_v_region = 0;
  125. int             current_v_clist = 0;
  126. int             current_v_call = 0;
  127. int             current_v_mount = 0;
  128.  
  129. int             g;
  130. int            *MyBuffer = NULL;
  131. int             inetd = 0;
  132.  
  133. struct mount_dir_pid_struct
  134. {
  135.   int             used;
  136.   char            dir[MTBUFSIZ];
  137.   int             pid;
  138. };
  139.  
  140.  
  141. #ifdef TESTING
  142. char            test_log[17];
  143. #endif
  144.  
  145. int             command_line_port = 0;
  146. int             default_file_port = 0;
  147.  
  148.  
  149. main (argc, argv)
  150.      int             argc;
  151.      char           *argv[];
  152. {
  153.  
  154.  
  155.   char            c;
  156.   setbuf (stdout, NULL);
  157.  
  158.   while ((c = getopt (argc, argv, "iu:p:s:k:m:")) != EOF)
  159.     {
  160.  
  161.       switch (c)
  162.     {
  163.  
  164.     case 'u':
  165.       kernel = optarg;
  166.       break;
  167.     case 'p':
  168.       sscanf (optarg, "%d", &command_line_port);
  169.       break;
  170.     case 'i':
  171.       inetd++;
  172.       break;
  173.     default:
  174.       break;
  175.     }
  176.     }
  177.  
  178. /*
  179.  * If inetd is spawning us, do not bind to the port, inetd will do it for
  180.  * us....
  181.  */
  182.  
  183.  
  184.   read_defaults_file ();
  185.  
  186.   if (!inetd)
  187.     CreateBinding ();        /* Bind a port to a socket */
  188.  
  189.   RunProgram ();        /* Run the application */
  190. }                /* end main */
  191.  
  192. xswsrv_write (data_pointer, data_size)
  193.      char           *data_pointer;
  194.      int             data_size;
  195. {
  196.   int             bytes_written;
  197.   int             total_written = 0;
  198.   int             interrupted = 1;
  199.   char           *temp_data_pointer = data_pointer;
  200.  
  201.   while (interrupted == 1)
  202.     {
  203.  
  204.       bytes_written = write (g, temp_data_pointer + total_written, data_size);
  205.  
  206.  
  207.       if ((bytes_written == -1) && (errno == EINTR))
  208.     {
  209. /*
  210.  * We were interrupted and NO data was written..... Thus re-write the
  211.  * whole thing....
  212.  */
  213.       interrupted = 1;
  214.     }
  215.       else if ((bytes_written != data_size) && (errno == EINTR))
  216.     {
  217. /*
  218.  * We were interrupted and SOME data was written ... Thus continue the
  219.  * write where we left off....
  220.  */
  221.       interrupted = 1;
  222.  
  223.       total_written += bytes_written;
  224. /*
  225.  * Some of the data was written...... need to write the rest......
  226.  */
  227.     }
  228.       else
  229.     {
  230.       total_written += bytes_written;
  231.       interrupted = 0;
  232.     }
  233.  
  234.     }
  235. /*
  236.  * If we lost connection, then lets just exit, but set exit code to 1......
  237.  */
  238.  
  239.   if (bytes_written < 0)
  240.     {
  241.       exit (1);
  242.     }
  243.  
  244. }
  245.  
  246. xswsrv_read (data_wanted, data_size)
  247.      int            *data_wanted;
  248.      int             data_size;
  249. {
  250.  
  251.   int             interrupted = 1;
  252.  
  253.   int             bytes_read;
  254.  
  255.  
  256. /*
  257.   fprintf(stdout,"G = %d, data_wanted = %d, data_size = %d\n",
  258.         g, data_wanted, data_size);
  259. */
  260.  
  261.  
  262.   while (interrupted == 1)
  263.     {
  264.  
  265.       bytes_read = read (g, data_wanted, data_size);
  266.  
  267. /*
  268.  * If we had a problem, and the problems is an interruped system call...
  269.  * Then we should try reading again.....
  270.  */
  271.  
  272.       if ((bytes_read == -1) && (errno == EINTR))
  273.     {
  274.       interrupted = 1;
  275. /*
  276.     fprintf(stdout,"We got interrupted....%d\n",bytes_read);
  277. */
  278.     }
  279.       else
  280.     {
  281. /*
  282.     fprintf(stdout,"We did not get interrupted....%d\n",bytes_read);
  283. */
  284.       interrupted = 0;
  285.     }
  286.  
  287.  
  288.  
  289. /*
  290.  * If we lost connection, then lets just exit, but set exit code to 1......
  291.  */
  292.  
  293.       if ((bytes_read <= 0) && (interrupted == 0))
  294.     {
  295. /*
  296.       perror("read:");
  297.       fprintf(stdout,"Bytes read = %d\n", bytes_read);
  298.       fprintf (stdout, "Leaving because of xswsrv read error\n");
  299. */
  300.       exit (2);
  301.     }
  302.  
  303.     }
  304.  
  305. }
  306.  
  307.  
  308. read_defaults_file ()
  309.  
  310. {
  311.  
  312.   int             def_fd;
  313.   char           *ptr;
  314.   extern char    *strdup ();
  315.  
  316.   if ((def_fd = defopen (DEFAULT)) == 0)
  317.     {
  318.       if ((ptr = defread ("PORT=")) != NULL)
  319.     {
  320.       sscanf (ptr, "%d", &default_file_port);
  321.     }
  322.       if ((ptr = defread ("CLIENTS=")) != NULL)
  323.     {
  324.       client_str = strdup (ptr);
  325.       found_client = 1;
  326.     }
  327.  
  328.  
  329.     close (def_fd); // close if defopen worked. 
  330.     }
  331. }
  332.  
  333.  
  334. /**********************************************************************
  335. CreateBinding
  336.         This procedure binds the FileDescriptor to a usable connection.
  337.         This is the most difficult part of the program to understand,
  338.         but once understood, it will be easy.  We have created a
  339.         logical socket with the socket function call.  However we
  340.         still need to bind the socket's file descriptor to the
  341.         <host.port> format.  This is done by setting the values of
  342.         the sockaddr_in structure.  For example:
  343.                 Sockaddr_in.sin_family=AF_INET  This is alway the same.
  344.                 Sockaddr_in.sin_port=portnumber  This number MUST be
  345.                         in a network byte order.  functions like
  346.                         getservbyname can be used to get the network
  347.                         byte order from an entry in /etc/services.
  348.                 SocketID,sin_addr.s_addr = INADDR_ANY will bind to
  349.                         host to any host, so if a host is considered
  350.                         a gateway, it will accept connections from
  351.                         both sides of the network.  Otherwise if a
  352.                         specific name is used, it will bind to only
  353.                         one side of the network.
  354. **********************************************************************/
  355. CreateBinding ()
  356. {
  357.  
  358.   int             Errval;
  359.   int             port;
  360.  
  361.   /* getservbyname only returns NULL, no error codes */
  362.  
  363. /*
  364.  * command line port over-rides all other defaults....
  365.  */
  366.  
  367.   if (command_line_port != 0)
  368.     port = command_line_port;
  369.   else
  370. /*
  371.  * /etc/default file
  372.  */
  373.  
  374.   if (default_file_port != 0)
  375.     port = default_file_port;
  376.   else
  377. /*
  378.  * /etc/services file.... and compiled in default....
  379.  */
  380.  
  381.   if ((ServiceNum = getservbyname (SOCKNAME, PROTOCOL)) == NULL)
  382.     port = XSWPORT;
  383.   else
  384.     port = ntohs (ServiceNum -> s_port);
  385.  
  386.   FileDescriptor = socket (AF_INET, SOCKTYPE, 0);    /* select auto configure */
  387.   if (FileDescriptor == -1)
  388.     {
  389.       perror ("Error Creating Socket\n");
  390. #ifdef TESTING
  391.       gct_writelog (test_log);
  392. #endif
  393.       exit (3);
  394.     }
  395.  
  396.   /* Set the Values to bind to specific <host.port> entity */
  397.  
  398.   bzero (&SocketID, sizeof (struct sockaddr_in));
  399.  
  400.  
  401.   SocketID.sin_family = AF_INET;/* This values is ALWAYS the same */
  402.   SocketID.sin_port = htons (port);    /* Bind to a specific Port */
  403.   /* The port must be in network byte order */
  404.   SocketID.sin_addr.s_addr = INADDR_ANY;    /* any host is ok */
  405.  
  406.   Errval = bind (FileDescriptor, (char *) &SocketID, sizeof (SocketID));
  407.   if (Errval)
  408.     {
  409.       perror ("Binding Error");
  410. #ifdef TESTING
  411.       gct_writelog (test_log);
  412. #endif
  413.       exit (4);
  414.     }
  415.  
  416. }
  417.  
  418. #define swapfunc(X)     sysi86(SI86SWPI, X)
  419.  
  420. typedef struct SwapDirs
  421. {
  422.   char           *sd_name;    /* Name of directory to search.  */
  423.   DIR            *sd_dirp;    /* DIR pointer.  */
  424. }               SwapDirs_t;
  425. SwapDirs_t      SwapDirs[] =
  426. {
  427.   {"/dev/dsk", NULL},
  428.   {"/dev", NULL},
  429. };
  430.  
  431. #define NbrSwapDirs     (sizeof(SwapDirs) / sizeof(SwapDirs_t))
  432.  
  433. typedef struct dirent dir_t;
  434.  
  435. char            PathBuf[PATHSIZE];
  436.  
  437. /*    Get path name corresponding to a device.
  438. */
  439.  
  440.  
  441. char           *
  442. SearchDir (sdp, dev)
  443.      SwapDirs_t     *sdp;
  444.      int             dev;
  445. {
  446.   dir_t          *dp;
  447.   struct stat     statbuf;
  448.  
  449.   while (dp = readdir (sdp -> sd_dirp))
  450.     {                /* L001 */
  451.       if (dp -> d_ino == 0)
  452.     continue;
  453.       sprintf (PathBuf, "%s", dp -> d_name);
  454.       if (stat (PathBuf, &statbuf) < 0)
  455.     {
  456. /*
  457.       fprintf (stderr,
  458.            "Could not stat %s.n",
  459.            PathBuf);
  460.       perror ("swap");
  461. */
  462.       continue;
  463.     }
  464.       if (statbuf.st_rdev != dev)
  465.     continue;
  466.       if ((statbuf.st_mode & S_IFMT) != S_IFBLK)
  467.     continue;
  468.       strcpy (PathBuf, sdp -> sd_name);
  469.       strcat (PathBuf, "/");
  470.       sprintf (&PathBuf[strlen (PathBuf)], "%s",
  471.            dp -> d_name);
  472.       return (PathBuf);
  473.     }
  474.   return (NULL);
  475. }
  476.  
  477. char           *
  478. GetPath (dev)
  479.      int             dev;
  480. {
  481.   int             sdndx;
  482.   char           *path;
  483.   char           *SearchDir ();
  484.  
  485.   for (sdndx = 0; sdndx < NbrSwapDirs; sdndx++)
  486.     {
  487.  
  488.       /*
  489.        * Skip any directories which we *    couldn't open.
  490.        */
  491.  
  492.       if (SwapDirs[sdndx].sd_dirp == NULL)    /* L001 */
  493.     continue;
  494.  
  495.       /*
  496.        * Change to directory we want to search.
  497.        */
  498.  
  499.       if (chdir (SwapDirs[sdndx].sd_name) < 0)
  500.     {
  501. /*
  502.       fprintf (stderr, "Couldn't chdir to %s",
  503.            SwapDirs[sdndx].sd_name);
  504.       fprintf (stderr, " - directory not searched.\n");
  505.       perror ("swap");
  506. */
  507.       SwapDirs[sdndx].sd_dirp = NULL;
  508.       continue;
  509.     }
  510.  
  511.       /*
  512.        * Position at start of directory.
  513.        */
  514.  
  515.       seekdir (SwapDirs[sdndx].sd_dirp, (long) 0);    /* L001 */
  516.  
  517.       if (path = SearchDir (&SwapDirs[sdndx], dev))
  518.     return (path);
  519.     }
  520.   return (NULL);
  521. }
  522.  
  523.  
  524. /*    Initialization for the path search routine.
  525. */
  526. void
  527. InitPath ()
  528. {
  529.   int             i;
  530.  
  531.   for (i = 0; i < NbrSwapDirs; i++)
  532.     {
  533.       SwapDirs[i].sd_dirp =
  534.     opendir (SwapDirs[i].sd_name);    /* L001 */
  535.       if (SwapDirs[i].sd_dirp == NULL)
  536.     {
  537. /*
  538.       fprintf (stderr, "Couldn't open directory %s",
  539.            SwapDirs[i].sd_name);
  540.       fprintf (stderr, " - not being searched.\n");
  541.       perror ("swap");
  542. */
  543.     }
  544.     }
  545. }
  546.  
  547. int
  548. get_nswap ()
  549. {
  550.   int             swplo;
  551.   int             blkcnt;
  552.   swpt_t         *st;
  553.   swpi_t         *si;
  554.   int             i;
  555.   swpt_t          swaptab[MSFILES];
  556.   swpi_t          swpi;
  557.   char           *path;
  558.   int             length;
  559.   char           *GetPath ();
  560.   int             total_pages = 0;
  561.  
  562.   st = swaptab;
  563.   si = &swpi;
  564.   si -> si_cmd = SI_LIST;
  565.   si -> si_buf = (char *) st;
  566.  
  567.   if (swapfunc (si) < 0)
  568.     {
  569.       return (0);
  570.     }
  571.  
  572.   InitPath ();
  573.  
  574.   for (i = 0; i < MSFILES; i++, st++)
  575.     {
  576.       if (st -> st_ucnt == NULL)
  577.     continue;
  578.       path = GetPath (st -> st_dev);
  579.  
  580.       total_pages += st -> st_npgs;
  581.     }
  582.  
  583.   return ((total_pages * NBPP) / 1024);
  584.  
  585. }
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593. /*+-------------------------------------------------------------------------
  594. uid to username conversion; thanks for the idea to William LeFebvre
  595. --------------------------------------------------------------------------*/
  596.  
  597. #ifdef OLDWAY
  598.  
  599. #define UID_NAME_HASH_SIZE    127    /* prime */
  600. #define HASH_EMPTY            32767
  601. #define HASHIT(i)            ((i) % UID_NAME_HASH_SIZE)
  602.  
  603. #endif
  604.  
  605. struct uid_name_hash_entry
  606. {
  607.   ushort          uid;
  608.   char            name[10];
  609. };
  610.  
  611. struct uid_name_hash_entry *uid_root_ptr = NULL;
  612.  
  613.  
  614. int
  615. uid_compare (node1, node2)
  616.      struct uid_name_hash_entry *node1, *node2;
  617.  
  618. {
  619.  
  620.   if ((struct uid_name_hash_entry *) node1 -> uid ==
  621.       (struct uid_name_hash_entry *) node2 -> uid)
  622.     return 0;
  623.  
  624.   if ((struct uid_name_hash_entry *) node1 -> uid <
  625.       (struct uid_name_hash_entry *) node2 -> uid)
  626.     return -1;
  627.  
  628.   if ((struct uid_name_hash_entry *) node1 -> uid >
  629.       (struct uid_name_hash_entry *) node2 -> uid)
  630.     return 1;
  631.  
  632. }
  633.  
  634.  
  635. #ifdef OLDWAY
  636. struct uid_name_hash_entry uid_name_table[UID_NAME_HASH_SIZE];
  637. int             uid_count = 0;
  638.  
  639. /*+-------------------------------------------------------------------------
  640.     init_uid_name_hash()
  641. --------------------------------------------------------------------------*/
  642. void
  643. init_uid_name_hash ()
  644. {
  645.   register int    ihash = 0;
  646.   register struct uid_name_hash_entry *hashent = uid_name_table;
  647.  
  648.   while (ihash++ < UID_NAME_HASH_SIZE)
  649.     {
  650.       hashent -> uid = HASH_EMPTY;
  651.       hashent++;
  652.     }
  653. }                /* end of init_uid_name_hash */
  654.  
  655. /*+-------------------------------------------------------------------------
  656.     uid_name_enter(uid,name)
  657. --------------------------------------------------------------------------*/
  658. int
  659. uid_name_enter (uid, name)
  660.      register ushort uid;
  661.      register char  *name;
  662. {
  663.   register ushort table_uid;
  664.   register int    hashval;
  665.  
  666.   if (++uid_count >= UID_NAME_HASH_SIZE - 1)
  667.     fprintf (stdout, "too many user names for me to handle");
  668.  
  669.   hashval = HASHIT (uid);
  670.   while ((table_uid = uid_name_table[hashval].uid) != HASH_EMPTY)
  671.     {
  672.       if (table_uid == uid)
  673.     return (hashval);
  674.       hashval = (hashval + 1) % UID_NAME_HASH_SIZE;
  675.     }
  676.  
  677.   uid_name_table[hashval].uid = uid;
  678.   (void) strncpy (uid_name_table[hashval].name, name,
  679.           sizeof (uid_name_table[0].name));
  680.  
  681.   return (hashval);
  682.  
  683. }                /* end of uid_name_enter */
  684.  
  685. /*+-------------------------------------------------------------------------
  686.     getpwent_and_enter(uid)
  687. --------------------------------------------------------------------------*/
  688. getpwent_and_enter (uid)
  689.      register ushort uid;
  690. {
  691.   register int    hashval;
  692.   register struct passwd *pwd;
  693.   char            errant[10];
  694.   struct passwd  *getpwuid ();
  695.  
  696.   pwd = getpwuid (uid);
  697.   endpwent ();
  698.   if (pwd)
  699.     {
  700.       hashval = uid_name_enter (pwd -> pw_uid, pwd -> pw_name);
  701.       return (hashval);
  702.     }
  703.   (void) sprintf (errant, "%u", uid);
  704.   return (uid_name_enter (uid, errant));
  705. }                /* end of getpwent_and_enter */
  706.  
  707. #endif
  708.  
  709. /*+-------------------------------------------------------------------------
  710.     uid_to_name(uid)
  711. --------------------------------------------------------------------------*/
  712. char           *
  713. uid_to_name (uid)
  714.      register ushort uid;
  715. {
  716.  
  717.   struct uid_name_hash_entry *uid_ptr;
  718.   struct uid_name_hash_entry **result_uid_ptr;
  719.  
  720.   register struct passwd *pwd;
  721.   struct passwd  *getpwuid ();
  722.  
  723.   uid_ptr = (struct uid_name_hash_entry *)
  724.     calloc (1, sizeof (struct uid_name_hash_entry));
  725.  
  726.   uid_ptr -> uid = uid;
  727.  
  728.   result_uid_ptr = (struct uid_name_hash_entry **)
  729.     tfind ((void *) uid_ptr, (void **) &uid_root_ptr,
  730.        uid_compare);
  731.  
  732. /*
  733.  * Not found in the tree....
  734.  */
  735.  
  736.   if (result_uid_ptr == NULL)
  737.     {
  738.  
  739.       pwd = getpwuid (uid);
  740.       endpwent ();
  741.  
  742.       uid_ptr -> uid = pwd -> pw_uid;
  743.  
  744.       strcpy (uid_ptr -> name, pwd -> pw_name);
  745.  
  746.       result_uid_ptr = (struct uid_name_hash_entry **)
  747.     tsearch ((char *) uid_ptr,
  748.          (char **) &uid_root_ptr,
  749.          uid_compare);
  750.  
  751.       return (uid_ptr -> name);
  752.  
  753.     }
  754.   else
  755.     {
  756.       free (uid_ptr);
  757.       return ((*result_uid_ptr) -> name);
  758.     }
  759.  
  760.  
  761.  
  762. #ifdef OLDWAY
  763.  
  764.   register int    uid_hash;
  765.   register ushort table_uid;
  766.  
  767.   uid_hash = HASHIT (uid);
  768.   while ((table_uid = uid_name_table[uid_hash].uid) != uid)
  769.     {
  770.       if (table_uid == HASH_EMPTY)
  771.     {
  772.       /* not in hash table */
  773.       uid_hash = getpwent_and_enter (uid);
  774.       break;        /* out of while */
  775.     }
  776.       uid_hash = (uid_hash + 1) % UID_NAME_HASH_SIZE;
  777.     }
  778.   return (uid_name_table[uid_hash].name);
  779.  
  780. #endif
  781. }                /* end of uid_to_name */
  782.  
  783.  
  784.  
  785.  
  786.  
  787.  
  788.  
  789.  
  790.  
  791. /*+-------------------------------------------------------------------------
  792.     read_utmp()
  793. --------------------------------------------------------------------------*/
  794. void
  795. read_utmp ()
  796. {
  797.   int             utmpfd;
  798.   register struct utmp *tutmp = utmps;
  799.   int             i = 0;
  800.   struct utmp    *temp_ptr;
  801.   int             result = 0;
  802.   static int      first_utmp_read = 1;
  803.  
  804.  
  805. /*
  806.  * Get the time of the utmp file, if it comes back with a bad result,
  807.  * then just read it.....
  808.  */
  809.  
  810.   result = stat (utmp_file, &utmp_stat);
  811.  
  812.   if ((utmp_stat.st_mtime != utmp_stat_old.st_mtime) ||
  813.       (utmp_stat.st_ctime != utmp_stat_old.st_ctime) ||
  814.       (first_utmp_read == 1) || (result != 0))
  815.     {
  816.  
  817.       first_utmp_read = 0;
  818.       utmp_stat_old = utmp_stat;
  819.  
  820.       nutmps = 0;
  821.       if ((utmpfd = open (utmp_file, O_RDONLY, 755)) < 0)
  822.     fprintf (stdout, "/etc/utmp open error");
  823.  
  824.       while (read (utmpfd, (char *) (tutmp++), sizeof (struct utmp)) > 0)
  825.     {
  826.       /*
  827.        * ensure null termination (clobbers 1st byte of ut_line, but we
  828.        * don't use it)
  829.        */
  830.       tutmp -> ut_id[sizeof (tutmp -> ut_id)] = 0;
  831.  
  832. /*
  833.  * Check to see if we need more space.......If so get some more.....
  834.  */
  835.  
  836.       if (++nutmps == utmps_size)
  837.         {
  838.  
  839.           temp_ptr = (struct utmp *) realloc
  840.         (utmps, (utmps_size + UTMPS_NUM) * sizeof (struct utmp));
  841.  
  842. /*
  843.  * Check to see if our addresse has changed... If so re-calculate tutmp
  844.  * position.....
  845.  */
  846.           utmps_size += UTMPS_NUM;
  847.  
  848.           if (temp_ptr != utmps)
  849.         {
  850.  
  851.           utmps = temp_ptr;
  852.  
  853.           tutmp = utmps;
  854.  
  855.           for (i = 0; i < nutmps; i++)
  856.             tutmp++;
  857.  
  858.         }
  859.         }
  860.     }
  861.       (void) close (utmpfd);
  862.  
  863.     }
  864. }                /* end of read_utmp */
  865.  
  866. /*+-------------------------------------------------------------------------
  867.     find_utmp_for_pgrp(pgrp)
  868. --------------------------------------------------------------------------*/
  869. struct utmp    *
  870. find_utmp_for_pgrp (pgrp)
  871.      int             pgrp;
  872. {
  873.   struct utmp    *tutmp = utmps;
  874.   register int    count = nutmps;
  875.  
  876.   while (count--)
  877.     {
  878.       if (tutmp -> ut_pid == pgrp)
  879.     return (tutmp);
  880.       tutmp++;
  881.     }
  882.   return ((struct utmp *) 0);
  883. }                /* end of find_utmp_for_pgrp */
  884.  
  885. /*+-------------------------------------------------------------------------
  886.     pgrp_to_ttyname(pgrp)
  887. --------------------------------------------------------------------------*/
  888. char           *
  889. pgrp_to_ttyname (pgrp)
  890.      int             pgrp;
  891. {
  892.   register        itmp;
  893.   struct utmp    *tutmp;
  894.  
  895.   if (!(tutmp = find_utmp_for_pgrp (pgrp)))
  896.     {
  897.       read_utmp ();
  898.       tutmp = find_utmp_for_pgrp (pgrp);
  899.     }
  900.   if (!tutmp)
  901.     return ("??");
  902.   else
  903.     {
  904.       itmp = strlen (tutmp -> ut_id);
  905.       return (&tutmp -> ut_id[(itmp >= 2) ? (itmp - 2) : 0]);
  906.     }
  907. }                /* end of pgrp_to_ttyname */
  908.  
  909. catch_child ()
  910. {
  911.  
  912.   int             wait_stat;
  913.  
  914.   waitpid (0, &wait_stat, WNOHANG);
  915.   signal (SIGCHLD, catch_child);
  916. /*
  917. fprintf(stdout,"WIF=%d,EXIT=%d,SIG=%d,TERM=%d,STOP=%d,STOPSIG=%d\n",
  918.             WIFEXITED(wait_stat),
  919.         WEXITSTATUS(wait_stat),
  920.         WIFSIGNALED(wait_stat),
  921.         WTERMSIG(wait_stat),
  922.         WIFSTOPPED(wait_stat),
  923.         WSTOPSIG(wait_stat));
  924.   fprintf(stdout,"in child catcher\n");
  925. */
  926.  
  927. }
  928.  
  929. catch_alarm ()
  930. {
  931.  
  932.   alarm_state = 1;
  933.   signal (SIGALRM, catch_alarm);
  934.  
  935. }
  936.  
  937. void
  938. get_filesystem_space (g)
  939.      int             g;
  940. {
  941.  
  942.  
  943.   int             w;
  944.   int             i;
  945.   int             k;
  946.  
  947.   char            dev[MTBUFSIZ];
  948.   char            dir[MTBUFSIZ];
  949.   short           flags;
  950.   time_t          time;
  951.   MTAB           *Mp;
  952.   struct statfs   Fs_info;
  953.   char           *mnt_file = "/etc/mnttab";
  954.   int             do_statfs = 0;
  955.   char           *temp_name = NULL;
  956.  
  957.   static struct disk_space_struct *current_disk_space = NULL;
  958.   struct disk_space_struct *temp_ptr;
  959.  
  960.   static struct mount_dir_pid_struct *pid_list = NULL;
  961.   static struct mount_dir_pid_struct *temp_pid_list = NULL;
  962.   static int      number_of_pids = 0;
  963.   int             found_opening = 0;
  964.  
  965.   int             pid;
  966.   int             do_fork;
  967.  
  968.   int             result;
  969.   int             wait_result;
  970.  
  971.   char           *char_result;
  972.  
  973.  
  974. /*
  975.  Open and read /etc/mnttab if it has been modified.....
  976. */
  977.  
  978.   result = stat (mnt_file, ¤t_mnt_stat);
  979.  
  980.   if ((first_mnt_stat == 1) || (result < 0) ||
  981.       (current_mnt_stat.st_mtime != mnt_stat.st_mtime))
  982.     {
  983.  
  984.       free (current_disk_space);
  985.       mnt_stat.st_mtime = current_mnt_stat.st_mtime;
  986.  
  987.       current_mnt_entries = 0;
  988.       first_mnt_stat = 0;
  989.  
  990.       if ((Mp = openmount (MTAB_ERROR)) == NULL)
  991.     {
  992. /*
  993.       fprintf (stdout, "Could not open mnttab ....\n");
  994. */
  995.       xswsrv_write (¤t_mnt_entries, sizeof (int));
  996.       xswsrv_write (current_disk_space,
  997.            current_mnt_entries * sizeof (struct disk_space_struct));
  998.       return;
  999.     }
  1000.  
  1001.       while (readmount (Mp, dev, MTBUFSIZ, dir, MTBUFSIZ, &flags, &time))
  1002.     {
  1003.  
  1004.       current_mnt_entries++;
  1005.  
  1006.       if (current_disk_space == NULL)
  1007.         {
  1008.           current_disk_space = (struct disk_space_struct *)
  1009.         malloc (sizeof (struct disk_space_struct));
  1010.         }
  1011.  
  1012.       else
  1013.         {
  1014.           temp_ptr = (struct disk_space_struct *) realloc
  1015.         (current_disk_space,
  1016.          (current_mnt_entries) * sizeof (struct disk_space_struct));
  1017.  
  1018.           if (temp_ptr != current_disk_space)
  1019.         {
  1020.           current_disk_space = temp_ptr;
  1021.         }
  1022.         }
  1023.  
  1024.  
  1025.       strcpy (current_disk_space[current_mnt_entries - 1].dev, dev);
  1026.       strcpy (current_disk_space[current_mnt_entries - 1].dir, dir);
  1027. /*
  1028.       fprintf(stdout,"XSWSRV: LEN = %d \n",
  1029.         strlen(current_disk_space[current_mnt_entries - 1].dir));
  1030.  
  1031.       fprintf(stdout,"XSWSRV: dir = %s\n",
  1032.         current_disk_space[current_mnt_entries - 1].dir);
  1033. */
  1034.  
  1035.       current_disk_space[current_mnt_entries - 1].mt_ro_flg = flags;
  1036.       current_disk_space[current_mnt_entries - 1].mt_time = time;
  1037.     }
  1038.  
  1039.       closemount (Mp);
  1040.  
  1041.  
  1042.     }
  1043.  
  1044.   for (w = 0; w < current_mnt_entries; w++)
  1045.  
  1046.     {
  1047.  
  1048.  
  1049. /*
  1050.       fprintf(stdout,"DEV = %s...DIR = %s\n",current_disk_space[w].dev,
  1051.                          current_disk_space[w].dir);
  1052. */
  1053.       temp_name = strdup (current_disk_space[w].dev);
  1054.  
  1055.       char_result = strchr (temp_name, ':');
  1056.  
  1057.       if (char_result != NULL)    /* If we have an NFS filesystem .... */
  1058.     {
  1059.  
  1060.       current_disk_space[w].nfs_filesystem = 1;
  1061.  
  1062. /*
  1063.  * Check to see if there is currently a child hanging on this filesytem
  1064.  * by looking into the pid_list array. If it is there, see if it
  1065.  * still alive by using kill(pid,0). If kill says it is there, then the
  1066.  * child is still hanging, and we should  not fork or statfs.... if it
  1067.  * is not alive any more then go ahead and fork again, otherwise set
  1068.  * do_statfs = 0
  1069.  */
  1070.  
  1071.       do_fork = 1;
  1072.  
  1073.       for (i = 0; i < number_of_pids; i++)
  1074.         {
  1075.  
  1076.           if ((pid_list[i].used == 1) &&
  1077.           (strcmp (pid_list[i].dir, current_disk_space[w].dir) == 0))
  1078.         {
  1079.  
  1080.           /*
  1081.            * If kill says it is not alive, then we must remove the
  1082.            * pid from the pid_list....
  1083.            */
  1084.  
  1085.           if (kill (pid_list[i].pid, 0) == 0)    /* if the pid is still
  1086.                              * alive */
  1087.             {
  1088.               /*
  1089.                * Do not fork and do not statfs for this filesystem...
  1090.                * It is still hanging.......
  1091.                */
  1092.               do_fork = 0;
  1093.               do_statfs = 0;
  1094.             }
  1095.           else
  1096.             {
  1097.               /*
  1098.                * Remove this pid from the list, and go ahead and fork
  1099.                * again....
  1100.                */
  1101.               pid_list[i].used = 0;
  1102.               do_fork = 1;
  1103.  
  1104.             }
  1105.         }
  1106.         }
  1107.  
  1108.  
  1109.       if (do_fork == 1)
  1110.         {
  1111.           switch (pid = fork ())
  1112.         {
  1113.  
  1114.           int             wait_stat;
  1115.  
  1116.         case 0:    /* Child process */
  1117.           result = statfs (current_disk_space[w].dir, &Fs_info,
  1118.                    sizeof (struct statfs), 0);
  1119.           exit (0);
  1120.           break;
  1121.  
  1122.         default:    /* Parent process */
  1123.           /*
  1124.            * Save the pid into an array so that we can determine if
  1125.            * the child is hanging or not. If it is still hanging on
  1126.            * the next interval, as determined by the kill(S), then we
  1127.            * should not fork! and we should not statfs!..... becuase
  1128.            * we had a timeout on that statfs
  1129.            */
  1130.  
  1131.  
  1132.           wait_stat = 0;
  1133.           alarm (1);    /* Set the alarm for 1 second.... */
  1134.           wait_result = waitpid ((pid_t) pid, &wait_stat, 0);
  1135. /*
  1136. fprintf(stdout,"WIF=%d,EXIT=%d,SIG=%d,TERM=%d,STOP=%d,STOPSIG=%d\n",
  1137.             WIFEXITED(wait_stat),
  1138.         WEXITSTATUS(wait_stat),
  1139.         WIFSIGNALED(wait_stat),
  1140.         WTERMSIG(wait_stat),
  1141.         WIFSTOPPED(wait_stat),
  1142.         WSTOPSIG(wait_stat));
  1143. */
  1144.  
  1145.           alarm (0);
  1146.           if (alarm_state == 1)    /* Child is hanging.... */
  1147.             {
  1148.               alarm_state = 0;
  1149.  
  1150.               /*
  1151.                * Add this pid to the list of hanging children...
  1152.                */
  1153.  
  1154.               if (pid_list == NULL)
  1155.             {
  1156.               number_of_pids = 1;
  1157.               pid_list = (struct mount_dir_pid_struct *)
  1158.                 malloc (sizeof (struct mount_dir_pid_struct));
  1159.  
  1160.               pid_list[number_of_pids - 1].used = 1;
  1161.               pid_list[number_of_pids - 1].pid = pid;
  1162.               strcpy (pid_list[number_of_pids - 1].dir,
  1163.                   current_disk_space[w].dir);
  1164.  
  1165.             }
  1166.               else
  1167.             /* See if there is an opening.... */
  1168.             {
  1169.               for (k = 0; k < number_of_pids; k++)
  1170.                 {
  1171.                   if (pid_list[k].used == 0)
  1172.                 {
  1173.                   /*
  1174.                    * Free up current space....
  1175.                    */
  1176.  
  1177.                   free (pid_list[k].dir);
  1178.  
  1179.                   pid_list[k].used = 1;
  1180.                   pid_list[k].pid = pid;
  1181.                   strcpy (pid_list[k].dir,
  1182.                       current_disk_space[w].dir);
  1183.  
  1184.                   found_opening = 1;
  1185.                 }
  1186.                 }
  1187.  
  1188.               if (found_opening == 0)
  1189.                 {
  1190.                   /*
  1191.                    * Expand pid_list....
  1192.                    */
  1193.                   number_of_pids++;
  1194.  
  1195.                   temp_pid_list = (struct mount_dir_pid_struct *) realloc
  1196.                 (pid_list,
  1197.                  (number_of_pids) * sizeof (struct mount_dir_pid_struct));
  1198.  
  1199.                   if (temp_pid_list != pid_list)
  1200.                 {
  1201.                   pid_list = temp_pid_list;
  1202.                 }
  1203.  
  1204.                   pid_list[number_of_pids - 1].used = 1;
  1205.                   pid_list[number_of_pids - 1].pid = pid;
  1206.                   strcpy (pid_list[number_of_pids - 1].dir,
  1207.                       current_disk_space[w].dir);
  1208.                 }
  1209.               found_opening = 0;
  1210.  
  1211.             }
  1212.               do_statfs = 0;
  1213.             }
  1214.           else
  1215.             {
  1216.               do_statfs = 1;
  1217.  
  1218.             }
  1219.           break;
  1220.  
  1221.         }
  1222.  
  1223.         }
  1224.  
  1225.     }
  1226.       else
  1227.     {
  1228.       do_statfs = 1;
  1229.       current_disk_space[w].nfs_filesystem = 0;
  1230.     }
  1231.  
  1232.       free (temp_name);
  1233.  
  1234.       if (do_statfs == 1)
  1235.     {
  1236.       result = statfs (current_disk_space[w].dir, &Fs_info,
  1237.                sizeof (struct statfs), 0);
  1238.     }
  1239.  
  1240.       /*
  1241.        * Save the information into my own data structure....
  1242.        */
  1243.  
  1244.       if (do_statfs == 1)
  1245.     {
  1246.       current_disk_space[w].problems = 0;
  1247.  
  1248.       current_disk_space[w].f_fstyp = Fs_info.f_fstyp;
  1249.       current_disk_space[w].f_bsize = Fs_info.f_bsize;
  1250.       current_disk_space[w].f_frsize = Fs_info.f_frsize;
  1251.       current_disk_space[w].f_blocks = Fs_info.f_blocks;
  1252.       current_disk_space[w].f_bfree = Fs_info.f_bfree;
  1253.       current_disk_space[w].f_files = Fs_info.f_files;
  1254.       current_disk_space[w].f_ffree = Fs_info.f_ffree;
  1255.       strcpy (current_disk_space[w].f_fname, Fs_info.f_fname);
  1256.       strcpy (current_disk_space[w].f_fpack, Fs_info.f_fpack);
  1257.  
  1258.  
  1259.     }
  1260.       else
  1261.     {
  1262.       current_disk_space[w].problems = 1;
  1263.  
  1264.       current_disk_space[w].f_fstyp = 0;
  1265.       current_disk_space[w].f_bsize = 0;
  1266.       current_disk_space[w].f_frsize = 0;
  1267.       current_disk_space[w].f_blocks = 0;
  1268.       current_disk_space[w].f_bfree = 0;
  1269.       current_disk_space[w].f_files = 0;
  1270.       current_disk_space[w].f_ffree = 0;
  1271.  
  1272.     }
  1273.  
  1274.     }
  1275.  
  1276.  
  1277.   xswsrv_write (¤t_mnt_entries, sizeof (int));
  1278.  
  1279.   xswsrv_write (current_disk_space,
  1280.         current_mnt_entries * sizeof (struct disk_space_struct));
  1281.  
  1282. }
  1283.  
  1284. int
  1285. get_os_version_identity()
  1286.  
  1287. {
  1288.  
  1289.   /*
  1290.    * Assum the following about the version:
  1291.    *
  1292.    *    32v4    =    0
  1293.    *    32v5    =    1
  1294.    */
  1295.  
  1296.    if ( x[BX_RRBSIZE].n_value != 0 )
  1297.        return 1;
  1298.    else
  1299.        return 0;
  1300.  
  1301. }
  1302.  
  1303. void
  1304. get_os_version_data(g)
  1305.  
  1306.     int    g;
  1307. {
  1308.   int        os_version = 0;
  1309.  
  1310.  /*
  1311.   * If Rbisze is defined in the kernel, then it must be a 32v5 system or
  1312.   * later.....
  1313.   */
  1314.  
  1315.   os_version = get_os_version_identity();
  1316.  
  1317.  
  1318.   xswsrv_write (&os_version, sizeof (int));
  1319.  
  1320. }
  1321.  
  1322.  
  1323.  
  1324. /****************************************************************************
  1325.     get_user_data(g)
  1326. *****************************************************************************/
  1327. void
  1328. get_user_data (g)
  1329.      int             g;
  1330. {
  1331.   int             i = 0;
  1332.   struct utmp    *utmp;
  1333.  
  1334.  
  1335.   setutent ();
  1336.   while ((utmp = getutent ()) != NULL)
  1337.     {
  1338.       if (utmp -> ut_type == USER_PROCESS)
  1339.     i++;
  1340.     }
  1341.  
  1342.   xswsrv_write (&i, sizeof (int));
  1343.  
  1344. }
  1345.  
  1346. /****************************************************************************
  1347.     get_freemem_data(g)
  1348. *****************************************************************************/
  1349. void
  1350. get_freemem_data (g)
  1351.      int             g;
  1352. {
  1353.   int             freemem_data_pointer;
  1354.  
  1355.   kread ((caddr_t) & freemem_data_pointer,
  1356.      x[BX_FREEMEM].n_value,
  1357.      sizeof (freemem_data_pointer));
  1358.  
  1359.   xswsrv_write (&freemem_data_pointer, sizeof (int));
  1360. }
  1361.  
  1362. /****************************************************************************
  1363.     get_availsmem_data(g)
  1364. *****************************************************************************/
  1365. void
  1366. get_availsmem_data (g)
  1367.      int             g;
  1368. {
  1369.   int             availsmem_data_pointer;
  1370.  
  1371.   kread ((caddr_t) & availsmem_data_pointer,
  1372.      x[BX_AVAILSMEM].n_value,
  1373.      sizeof (availsmem_data_pointer));
  1374.  
  1375.   xswsrv_write (&availsmem_data_pointer, sizeof (availsmem_data_pointer));
  1376. }
  1377.  
  1378. /****************************************************************************
  1379.         get_boot_time(g)
  1380. *****************************************************************************/
  1381. get_boot_time (g)
  1382.      int             g;
  1383. {
  1384.  
  1385.   time_t          boot_time;
  1386.  
  1387.   kread ((caddr_t) & boot_time,
  1388.      x[BX_BOOT_TIME].n_value,
  1389.      sizeof (time_t));
  1390.  
  1391.   xswsrv_write (&boot_time, sizeof (time_t));
  1392.  
  1393. }
  1394.  
  1395. /****************************************************************************
  1396.     get_sysinfo_data(g)
  1397. *****************************************************************************/
  1398. void
  1399. get_sysinfo_data (g)
  1400.      int             g;
  1401. {
  1402.   struct sysinfo *sysinfo_data_pointer = NULL;
  1403.  
  1404.   sysinfo_data_pointer = (struct sysinfo *) malloc (sizeof (struct sysinfo));
  1405.  
  1406.   kread ((caddr_t) sysinfo_data_pointer,
  1407.      x[BX_SYSINFO].n_value,
  1408.      sizeof (struct sysinfo));
  1409.  
  1410.   xswsrv_write (sysinfo_data_pointer, sizeof (struct sysinfo));
  1411.  
  1412.   free (sysinfo_data_pointer);
  1413.  
  1414. }
  1415.  
  1416. /****************************************************************************
  1417.     get_minfo_data(g)
  1418. *****************************************************************************/
  1419. void
  1420. get_minfo_data (g)
  1421.      int             g;
  1422. {
  1423.   struct minfo   *minfo_data_pointer = NULL;
  1424.  
  1425.   minfo_data_pointer = (struct minfo *) malloc (sizeof (struct minfo));
  1426.  
  1427.   kread ((caddr_t) minfo_data_pointer,
  1428.      x[BX_MINFO].n_value,
  1429.      sizeof (struct minfo));
  1430.  
  1431.   xswsrv_write (minfo_data_pointer, sizeof (struct minfo));
  1432.  
  1433.   free (minfo_data_pointer);
  1434. }
  1435.  
  1436. /****************************************************************************
  1437.     get_tune_data(g)
  1438. *****************************************************************************/
  1439. void
  1440. get_tune_data (g)
  1441.      int             g;
  1442. {
  1443.   struct tune    *tune_data_pointer = NULL;
  1444.  
  1445.   tune_data_pointer = (struct tune *) malloc (sizeof (struct tune));
  1446.  
  1447.   kread ((caddr_t) tune_data_pointer,
  1448.      x[BX_TUNE].n_value,
  1449.      sizeof (struct tune));
  1450.  
  1451.   xswsrv_write (tune_data_pointer, sizeof (struct tune));
  1452.  
  1453.   free (tune_data_pointer);
  1454.  
  1455. }
  1456.  
  1457. /****************************************************************************
  1458.     initialize_var_data()
  1459. *****************************************************************************/
  1460. void
  1461. initialize_var_data ()
  1462. {
  1463.  
  1464.   struct var     *var_data_pointer = NULL;
  1465.  
  1466.   var_data_pointer = (struct var *) malloc (sizeof (struct var));
  1467.  
  1468.   kread ((caddr_t) var_data_pointer,
  1469.      x[BX_V].n_value,
  1470.      sizeof (struct var));
  1471.  
  1472.   current_v_proc = var_data_pointer -> v_proc;
  1473.   current_v_file = var_data_pointer -> v_file;
  1474.   current_v_inode = var_data_pointer -> v_inode;
  1475.   current_v_region = var_data_pointer -> v_region;
  1476.   current_v_clist = var_data_pointer -> v_clist;
  1477. #ifndef XSW32v5
  1478.   current_v_call = var_data_pointer -> v_call;
  1479. #endif
  1480.   current_v_mount = var_data_pointer -> v_mount;
  1481.  
  1482.   free (var_data_pointer);
  1483. }
  1484.  
  1485. /****************************************************************************
  1486.     get_var_data(g)
  1487. *****************************************************************************/
  1488. void
  1489. get_var_data (g)
  1490.      int             g;
  1491. {
  1492.  
  1493.   struct var     *var_data_pointer = NULL;
  1494.  
  1495.   var_data_pointer = (struct var *) malloc (sizeof (struct var));
  1496.  
  1497.   kread ((caddr_t) var_data_pointer,
  1498.      x[BX_V].n_value,
  1499.      sizeof (struct var));
  1500.  
  1501.   xswsrv_write (var_data_pointer, sizeof (struct var));
  1502.  
  1503.   current_v_proc = var_data_pointer -> v_proc;
  1504.   current_v_file = var_data_pointer -> v_file;
  1505.   current_v_inode = var_data_pointer -> v_inode;
  1506.   current_v_region = var_data_pointer -> v_region;
  1507.   current_v_clist = var_data_pointer -> v_clist;
  1508. #ifndef XSW32v5
  1509.   current_v_call = var_data_pointer -> v_call;
  1510. #endif
  1511.   current_v_mount = var_data_pointer -> v_mount;
  1512.  
  1513.   free (var_data_pointer);
  1514. }
  1515.  
  1516.  
  1517. /****************************************************************************
  1518.     get_bootstring_data(g)
  1519. *****************************************************************************/
  1520. void
  1521. get_bootstring_data (g)
  1522.      int             g;
  1523. {
  1524.  
  1525.   char            my_bs_bootstring[B_MAXSTRLEN];
  1526.  
  1527.   int             string_size;
  1528.  
  1529.   char           *strings = NULL;
  1530.  
  1531.   kread ((caddr_t) & string_size,
  1532.      x[BX_STRING_SIZE].n_value,
  1533.      sizeof (string_size));
  1534.  
  1535.   strings = (char *) malloc (string_size);
  1536.  
  1537.   kread ((caddr_t) strings,
  1538.      x[BX_STRING].n_value,
  1539.      string_size);
  1540.  
  1541.  
  1542.   kread ((caddr_t) & my_bs_bootstring,
  1543.      x[BX_BOOTSTRING].n_value,
  1544.      sizeof (my_bs_bootstring));
  1545.  
  1546.   xswsrv_write (&my_bs_bootstring, sizeof (my_bs_bootstring));
  1547.  
  1548.   xswsrv_write (&string_size, sizeof (int));
  1549.   xswsrv_write (strings, string_size);
  1550.  
  1551.   free (strings);
  1552.  
  1553. }
  1554.  
  1555.  
  1556.  
  1557.  
  1558. /****************************************************************************
  1559.     get_bootinfo_data(g)
  1560. *****************************************************************************/
  1561. void
  1562. get_bootinfo_data (g)
  1563.      int             g;
  1564. {
  1565.   struct bootinfo *bootinfo_data_pointer = NULL;
  1566.  
  1567.   bootinfo_data_pointer = (struct bootinfo *) malloc (sizeof (struct bootinfo));
  1568.  
  1569.   kread ((caddr_t) bootinfo_data_pointer,
  1570.      x[BX_BOOTINFO].n_value,
  1571.      sizeof (struct bootinfo));
  1572.  
  1573.   xswsrv_write (bootinfo_data_pointer, sizeof (struct bootinfo));
  1574.  
  1575.   free (bootinfo_data_pointer);
  1576.  
  1577. }
  1578.  
  1579. /****************************************************************************
  1580.     get_maxmem_data(g)
  1581. *****************************************************************************/
  1582. void
  1583. get_maxmem_data (g)
  1584.      int             g;
  1585. {
  1586.   int             maxmem_data_pointer;
  1587.  
  1588.   kread ((caddr_t) & maxmem_data_pointer,
  1589.      x[BX_MAXMEM].n_value,
  1590.      sizeof (int));
  1591.  
  1592.   xswsrv_write (&maxmem_data_pointer, sizeof (int));
  1593.  
  1594. }
  1595.  
  1596. /****************************************************************************
  1597.     get_nswap_data(g)
  1598. *****************************************************************************/
  1599. void
  1600. get_nswap_data (g)
  1601.      int             g;
  1602. {
  1603.   int             my_nswap;
  1604.  
  1605.  
  1606.   my_nswap = get_nswap ();
  1607.  
  1608.   xswsrv_write (&my_nswap, sizeof (int));
  1609.  
  1610. }
  1611.  
  1612. /****************************************************************************
  1613.     get_files_data(g)
  1614. *****************************************************************************/
  1615. void
  1616. get_files_data (g)
  1617.      int             g;
  1618. {
  1619.   struct file    *files_data_pointer = NULL;
  1620.   struct var     *var_data_pointer = NULL;
  1621.   int             file_count;
  1622.   int             i = 0;
  1623.   int             config_files;
  1624. /*
  1625.  * Experiment: Use read_size to dermine the best read size so that we reduce
  1626.  * the over head of reading /dev/mem, but not at the expense of memory.....
  1627.  */
  1628.  
  1629.   int             read_size = 1;
  1630.  
  1631.   config_files = current_v_file;
  1632.  
  1633.   files_data_pointer = (struct file *)
  1634.     malloc (read_size * sizeof (struct file));
  1635.  
  1636.   file_count = 0;
  1637.  
  1638. /*
  1639.  * Need to modify this part for read_size variable......
  1640.  */
  1641.  
  1642.   for (i = 0; i < config_files; i++)
  1643.     {
  1644.       kread ((caddr_t) files_data_pointer,
  1645.          x[BX_FILES].n_value + (sizeof (struct file) * i),
  1646.          sizeof          (struct file));
  1647.  
  1648.       if (files_data_pointer -> f_count)
  1649.     file_count++;
  1650.  
  1651.     }
  1652.  
  1653.   free (files_data_pointer);
  1654.   xswsrv_write (&file_count, sizeof (int));
  1655. }
  1656.  
  1657. /****************************************************************************
  1658.     get_indoes_data(g)
  1659. *****************************************************************************/
  1660. void
  1661. get_inodes_data (g)
  1662.      int             g;
  1663. {
  1664.  
  1665.   struct var     *var_data_pointer = NULL;
  1666.   struct inode   *inodes_data_pointer = NULL;
  1667.   int             i = 0;
  1668.   int             config_inodes;
  1669.   int             inode_count;
  1670.  
  1671.   config_inodes = current_v_inode;
  1672.  
  1673.   inodes_data_pointer = (struct inode *) malloc (sizeof (struct inode));
  1674.  
  1675.   inode_count = 0;
  1676.  
  1677.   for (i = 0; i < config_inodes; i++)
  1678.     {
  1679.       kread ((caddr_t) inodes_data_pointer,
  1680.          x[BX_INODE].n_value + (sizeof (struct inode) * i),
  1681.          sizeof          (struct inode));
  1682.  
  1683.       if (inodes_data_pointer -> i_count)
  1684.     inode_count++;
  1685.  
  1686.     }
  1687.  
  1688.   free (inodes_data_pointer);
  1689.   xswsrv_write (&inode_count, sizeof (int));
  1690.  
  1691. }
  1692.  
  1693. /****************************************************************************
  1694.     get_procs_data(g)
  1695. *****************************************************************************/
  1696. void
  1697. get_procs_data (g)
  1698.      int             g;
  1699. {
  1700.  
  1701.   struct proc    *procs_data_pointer = NULL;
  1702.   struct var     *var_data_pointer = NULL;
  1703.  
  1704.   int             i = 0;
  1705.   int             config_procs;
  1706.   int             proc_count;
  1707.  
  1708.   config_procs = current_v_proc;
  1709.  
  1710.   procs_data_pointer = (struct proc *) malloc (sizeof (struct proc));
  1711.  
  1712.   proc_count = 0;
  1713.  
  1714.   for (i = 0; i < config_procs; i++)
  1715.     {
  1716.       kread ((caddr_t) procs_data_pointer,
  1717.          x[BX_PROCS].n_value + (sizeof (struct proc) * i),
  1718.          sizeof          (struct proc));
  1719.  
  1720.       if (procs_data_pointer -> p_stat)
  1721.     proc_count++;
  1722.  
  1723.     }
  1724.  
  1725.   free (procs_data_pointer);
  1726.   xswsrv_write (&proc_count, sizeof (int));
  1727.  
  1728. }
  1729.  
  1730. /****************************************************************************
  1731.     get_regions_data(g)
  1732. *****************************************************************************/
  1733. void
  1734. get_regions_data (g)
  1735.      int             g;
  1736. {
  1737.  
  1738.   reg_t          *regions_data_pointer = NULL;
  1739.   struct var     *var_data_pointer = NULL;
  1740.  
  1741.   int             i = 0;
  1742.   int             config_regions;
  1743.   int             region_count;
  1744.  
  1745.   config_regions = current_v_region;
  1746.  
  1747.   regions_data_pointer = (reg_t *) malloc (sizeof (reg_t));
  1748.  
  1749.   region_count = 0;
  1750.  
  1751.   for (i = 0; i < config_regions; i++)
  1752.     {
  1753.       kread ((caddr_t) regions_data_pointer,
  1754.          x[BX_REGION].n_value + (sizeof (reg_t) * i),
  1755.          sizeof (reg_t));
  1756.  
  1757.       if (regions_data_pointer -> r_type != RT_UNUSED)
  1758.     region_count++;
  1759.  
  1760.     }
  1761.  
  1762.   free (regions_data_pointer);
  1763.   xswsrv_write (®ion_count, sizeof (int));
  1764.  
  1765. }
  1766.  
  1767. /*+-------------------------------------------------------------------------
  1768.     get_cblocks_data()
  1769. --------------------------------------------------------------------------*/
  1770. void
  1771. get_cblocks_data (g)
  1772.      int             g;
  1773. {
  1774.  
  1775.   struct var     *var_data_pointer = NULL;
  1776.   struct cblock  *cfree, *tmp;
  1777.   static struct cblock *addr = (struct cblock *) 0;
  1778.   struct chead    cfreelist;
  1779.  
  1780.   int             j, i, index;
  1781.   static int      count[2];
  1782.  
  1783.   int             myclist = 0;
  1784.   int             config_clist = 0;
  1785.  
  1786.   config_clist = current_v_clist;
  1787.  
  1788.   cfree = (struct cblock *) malloc (sizeof (*cfree) * config_clist);
  1789.  
  1790.   if (cfree == NULL)
  1791.     perror ("cblocks: malloc");
  1792.  
  1793.   if (addr == (struct cblock *) 0)
  1794.     kread ((caddr_t) & addr, x[BX_CBLOCKS].n_value, sizeof (struct cblock *));
  1795.  
  1796.   for (j = 0; j < 2; j++)
  1797.     {
  1798.       kread ((caddr_t) (char *) cfree, (int) addr, sizeof (*cfree) * config_clist);
  1799.       kread ((caddr_t) (char *) &cfreelist, x[BX_CFREELIST].n_value,
  1800.          sizeof (struct chead));
  1801.  
  1802.       index = cfreelist.c_next - addr;
  1803.  
  1804.       tmp = &cfree[index];
  1805.       count[j] = 0;
  1806.       for (i = 0; tmp -> c_next && i < config_clist; i++)
  1807.     {
  1808.       index = tmp -> c_next - addr;
  1809.       count[j]++;
  1810.       tmp = &cfree[index];
  1811.  
  1812.     }
  1813.     }
  1814.  
  1815.   free (cfree);
  1816.  
  1817.   if ((abs (count[0] - count[1])) > (config_clist * 10) / 100)
  1818.     myclist = (config_clist - ((count[0] > count[1]) ? count[0] : count[1]));
  1819.   else
  1820.     myclist = (config_clist - (min (count[0], count[1])));
  1821.  
  1822.  
  1823.   xswsrv_write (&myclist, sizeof (int));
  1824.  
  1825. }
  1826.  
  1827. /*+-------------------------------------------------------------------------
  1828.     get_call_data()
  1829. --------------------------------------------------------------------------*/
  1830. void
  1831. get_call_data (g)
  1832.      int             g;
  1833. {
  1834.  
  1835.   struct callo   *my_callout = NULL;
  1836.  
  1837.   int             number_of_callout;
  1838.   int             callout_count = 0;
  1839.   int             i = 0;
  1840.  
  1841.   number_of_callout = current_v_call;
  1842.  
  1843.   my_callout = (struct callo *)
  1844.     calloc (number_of_callout, sizeof (struct callo));
  1845.  
  1846.   kread ((caddr_t) my_callout,
  1847.      x[BX_CALLOUT].n_value,
  1848.      sizeof (struct callo) * number_of_callout);
  1849.  
  1850.   for (i = 0; i < number_of_callout; i++)
  1851.     {
  1852.       if (my_callout[i].c_func != NULL)
  1853.     callout_count++;
  1854.     }
  1855.  
  1856.   free (my_callout);
  1857.  
  1858.   xswsrv_write (&callout_count, sizeof (int));
  1859.  
  1860.  
  1861. }
  1862.  
  1863. /*+-------------------------------------------------------------------------
  1864.         get_mount_data()
  1865. --------------------------------------------------------------------------*/
  1866. void
  1867. get_mount_data (g)
  1868.      int             g;
  1869. {
  1870.  
  1871.   struct mount   *my_mount = NULL;
  1872.  
  1873.   int             number_of_mounts;
  1874.   int             mount_count = 0;
  1875.   int             i = 0;
  1876.  
  1877.   number_of_mounts = current_v_mount;
  1878.  
  1879.   my_mount = (struct mount *)
  1880.     calloc (number_of_mounts, sizeof (struct mount));
  1881.  
  1882.   kread ((caddr_t) my_mount,
  1883.      x[BX_MOUNT].n_value,
  1884.      sizeof (struct mount) * number_of_mounts);
  1885.  
  1886.   for (i = 0; i < number_of_mounts; i++)
  1887.     {
  1888.       if (my_mount[i].m_flags != 0)
  1889.     mount_count++;
  1890.     }
  1891.  
  1892.   free (my_mount);
  1893.  
  1894.   xswsrv_write (&mount_count, sizeof (int));
  1895.  
  1896.  
  1897. }
  1898.  
  1899. /****************************************************************************
  1900.     get_streams_data(g)
  1901. *****************************************************************************/
  1902. void
  1903. get_streams_data (g)
  1904.      int             g;
  1905. {
  1906.  
  1907.  
  1908.   struct strstat *mystreams;
  1909.   int             mynmblock;
  1910.  
  1911.   struct pagestat pagest;
  1912.   uint        *rbsizep32v5 = NULL;
  1913.   ushort     *rbsizep32v4 = NULL;
  1914.  
  1915.   mystreams = (struct strstat *) malloc (sizeof (struct strstat));
  1916.  
  1917.   kread ((caddr_t) mystreams,
  1918.      x[BX_STREAMS].n_value,
  1919.      sizeof (struct strstat));
  1920.  
  1921.   kread ((caddr_t) & mynmblock,
  1922.      x[BX_NMBLOCK].n_value,
  1923.      sizeof (mynmblock));
  1924.  
  1925.  
  1926.   xswsrv_write (mystreams, sizeof (struct strstat));
  1927.   xswsrv_write (&mynmblock, sizeof (int));
  1928.  
  1929.  
  1930.  /*
  1931.   * If this is a 32v5 system, then we need to send some more data....
  1932.   */
  1933.  
  1934.   if ( get_os_version_identity() == 1 )
  1935.     {
  1936.  
  1937.         kread ((caddr_t) & pagest,
  1938.          x[BX_PAGEST].n_value,
  1939.          sizeof (struct pagestat));
  1940.     
  1941.       rbsizep32v5 = (uint *)malloc(15 * sizeof(uint));
  1942.  
  1943.         kread ((caddr_t) rbsizep32v5,
  1944.          x[BX_RRBSIZE].n_value,
  1945.          15 * sizeof(uint));
  1946.  
  1947.         xswsrv_write (&pagest, sizeof (struct pagestat));
  1948.         xswsrv_write (rbsizep32v5 ,15 * sizeof(uint));
  1949.     } else
  1950.   if ( get_os_version_identity() == 0 )
  1951.     {
  1952.       rbsizep32v4 = (ushort *)malloc(9 * sizeof(ushort));
  1953.  
  1954.         kread ((caddr_t) rbsizep32v4,
  1955.          x[BX_RBSIZE].n_value,
  1956.          9 * sizeof(ushort));
  1957.  
  1958.         xswsrv_write (rbsizep32v4 ,9 * sizeof(ushort));
  1959.     }
  1960.  
  1961.  
  1962.  
  1963.  
  1964.   free (mystreams);
  1965.   
  1966.   if (rbsizep32v5 != NULL)
  1967.     free (rbsizep32v5);
  1968.   if (rbsizep32v4 != NULL)
  1969.     free (rbsizep32v4);
  1970.  
  1971. }
  1972.  
  1973. /****************************************************************************
  1974.     get_nfs_data(g)
  1975. *****************************************************************************/
  1976. void
  1977. get_nfs_data (g)
  1978.      int             g;
  1979. {
  1980.  
  1981.   kread ((caddr_t) & rcstat, x[BX_RCSTAT].n_value, sizeof (rcstat));
  1982.   kread ((caddr_t) & clstat, x[BX_CLSTAT].n_value, sizeof (clstat));
  1983.   kread ((caddr_t) & rsstat, x[BX_RSSTAT].n_value, sizeof (rsstat));
  1984.   kread ((caddr_t) & svstat, x[BX_SVSTAT].n_value, sizeof (svstat));
  1985.  
  1986.   xswsrv_write (&rcstat, sizeof (rcstat));
  1987.   xswsrv_write (&rsstat, sizeof (rsstat));
  1988.   xswsrv_write (&clstat, sizeof (clstat));
  1989.   xswsrv_write (&svstat, sizeof (svstat));
  1990.  
  1991.  
  1992. }
  1993.  
  1994. /****************************************************************************
  1995.     get_nfs_available(g)
  1996. *****************************************************************************/
  1997. void
  1998. get_nfs_available (g)
  1999.      int             g;
  2000. {
  2001.  
  2002.   int             nfs_available = 0;
  2003.  
  2004.   if (x[BX_RCSTAT].n_value != 0)
  2005.     {
  2006.       nfs_available = 1;
  2007.     }
  2008.  
  2009.   xswsrv_write (&nfs_available, sizeof (nfs_available));
  2010.  
  2011.  
  2012. }
  2013.  
  2014. /****************************************************************************
  2015.     get_floppy_disk_available(g)
  2016. *****************************************************************************/
  2017. void
  2018. get_floppy_disk_available (g)
  2019. {
  2020.  
  2021.   int             floppy_available = 0;
  2022.  
  2023.   if (x[BX_FLOPPY_DISK_STATS].n_value != 0)
  2024.     {
  2025.       floppy_available = 1;
  2026.     }
  2027.  
  2028.   xswsrv_write (&floppy_available, sizeof (floppy_available));
  2029.  
  2030.  
  2031. }
  2032.  
  2033. /****************************************************************************
  2034.     get_scsi_disk_available(g)
  2035. *****************************************************************************/
  2036. void
  2037. get_scsi_disk_available (g)
  2038. {
  2039.  
  2040.   int             scsi_disk_available = 0;
  2041.  
  2042.   if (x[BX_SCSI_DISK_STATS].n_value != 0)
  2043.     {
  2044.       scsi_disk_available = 1;
  2045.     }
  2046.  
  2047.   xswsrv_write (&scsi_disk_available, sizeof (scsi_disk_available));
  2048.  
  2049.  
  2050. }
  2051.  
  2052. /****************************************************************************
  2053.     get_scsi_tape_available(g)
  2054. *****************************************************************************/
  2055. void
  2056. get_scsi_tape_available (g)
  2057. {
  2058.  
  2059.   int             scsi_tape_available = 0;
  2060.  
  2061.   if (x[BX_SCSI_TAPE_STATS].n_value != 0)
  2062.     {
  2063.       scsi_tape_available = 1;
  2064.     }
  2065.  
  2066.   xswsrv_write (&scsi_tape_available, sizeof (scsi_tape_available));
  2067.  
  2068.  
  2069. }
  2070.  
  2071. /****************************************************************************
  2072.     get_scsi_rom_available(g)
  2073. *****************************************************************************/
  2074. void
  2075. get_scsi_rom_available (g)
  2076. {
  2077.  
  2078.   int             scsi_rom_available = 0;
  2079.  
  2080.   if (x[BX_SCSI_ROM_STATS].n_value != 0)
  2081.     {
  2082.       scsi_rom_available = 1;
  2083.     }
  2084.  
  2085.   xswsrv_write (&scsi_rom_available, sizeof (scsi_rom_available));
  2086.  
  2087. }
  2088.  
  2089. /****************************************************************************
  2090.     get_cart_tape_available(g)
  2091. *****************************************************************************/
  2092. void
  2093. get_cart_tape_available (g)
  2094. {
  2095.  
  2096.   int             cart_tape_available = 0;
  2097.  
  2098.   if (x[BX_CART_TAPE_STATS].n_value != 0)
  2099.     {
  2100.       cart_tape_available = 1;
  2101.     }
  2102.  
  2103.   xswsrv_write (&cart_tape_available, sizeof (cart_tape_available));
  2104.  
  2105. }
  2106.  
  2107. /****************************************************************************
  2108.     get_esdi_disk_available(g)
  2109. *****************************************************************************/
  2110. void
  2111. get_esdi_disk_available (g)
  2112. {
  2113.  
  2114.   int             esdi_disk_available = 0;
  2115.  
  2116.   if (x[BX_ESDI_DISK_STATS].n_value != 0)
  2117.     {
  2118.       esdi_disk_available = 1;
  2119.     }
  2120.  
  2121.   xswsrv_write (&esdi_disk_available, sizeof (esdi_disk_available));
  2122.  
  2123. }
  2124.  
  2125. /****************************************************************************
  2126.     get_wd_disk_available(g)
  2127. *****************************************************************************/
  2128. void
  2129. get_wd_disk_available (g)
  2130. {
  2131.  
  2132.   int             wd_disk_available = 0;
  2133.  
  2134.   if (x[BX_WD_DISK_STATS].n_value != 0)
  2135.     {
  2136.       wd_disk_available = 1;
  2137.     }
  2138.  
  2139.   xswsrv_write (&wd_disk_available, sizeof (wd_disk_available));
  2140.  
  2141. }
  2142.  
  2143.  
  2144.  
  2145.  
  2146. /****************************************************************************
  2147.         get_floppy_disk_data(g)
  2148. *****************************************************************************/
  2149. void
  2150. get_floppy_disk_data (g)
  2151.      int             g;
  2152. {
  2153.  
  2154.   struct iotime   floppy_disk_stats[4];
  2155.  
  2156.  
  2157.   kread ((caddr_t) & floppy_disk_stats,
  2158.      x[BX_FLOPPY_DISK_STATS].n_value,
  2159.      sizeof (floppy_disk_stats));
  2160.  
  2161.   xswsrv_write (&floppy_disk_stats, sizeof (floppy_disk_stats));
  2162. }
  2163.  
  2164. /****************************************************************************
  2165.         get_scsi_disk_data(g)
  2166. *****************************************************************************/
  2167. void
  2168. get_scsi_disk_data (g)
  2169.      int             g;
  2170. {
  2171.  
  2172.   struct iotime   Sdsk_stats[4];
  2173.  
  2174.   kread ((caddr_t) & Sdsk_stats,
  2175.      x[BX_SCSI_DISK_STATS].n_value,
  2176.      sizeof (Sdsk_stats));
  2177.  
  2178.   xswsrv_write (&Sdsk_stats, sizeof (Sdsk_stats));
  2179. }
  2180.  
  2181. /****************************************************************************
  2182.         get_scsi_tape_data(g)
  2183. *****************************************************************************/
  2184. void
  2185. get_scsi_tape_data (g)
  2186.      int             g;
  2187. {
  2188.  
  2189.   struct iotime   Stp_stats[4];
  2190.  
  2191.   kread ((caddr_t) & Stp_stats,
  2192.      x[BX_SCSI_TAPE_STATS].n_value,
  2193.      sizeof (Stp_stats));
  2194.  
  2195.   xswsrv_write (&Stp_stats, sizeof (Stp_stats));
  2196. }
  2197.  
  2198.  
  2199. /****************************************************************************
  2200.         get_scsi_rom_data(g)
  2201. *****************************************************************************/
  2202. void
  2203. get_scsi_rom_data (g)
  2204.      int             g;
  2205. {
  2206.  
  2207.   struct iotime   Srom_stats[4];
  2208.  
  2209.   kread ((caddr_t) & Srom_stats,
  2210.      x[BX_SCSI_ROM_STATS].n_value,
  2211.      sizeof (Srom_stats));
  2212.  
  2213.   xswsrv_write (&Srom_stats, sizeof (Srom_stats));
  2214. }
  2215.  
  2216. /****************************************************************************
  2217.         get_cart_tape_data(g)
  2218. *****************************************************************************/
  2219. void
  2220. get_cart_tape_data (g)
  2221.      int             g;
  2222. {
  2223.  
  2224.   struct iotime   cart_tape_stats[4];
  2225.  
  2226.   kread ((caddr_t) & cart_tape_stats,
  2227.      x[BX_CART_TAPE_STATS].n_value,
  2228.      sizeof (cart_tape_stats));
  2229.  
  2230.   xswsrv_write (&cart_tape_stats, sizeof (cart_tape_stats));
  2231. }
  2232.  
  2233. /****************************************************************************
  2234.         get_esdi_disk_data(g)
  2235. *****************************************************************************/
  2236. void
  2237. get_esdi_disk_data (g)
  2238.      int             g;
  2239. {
  2240.  
  2241.   struct iotime   esdi_disk_stats[4];
  2242.  
  2243.   kread ((caddr_t) & esdi_disk_stats,
  2244.      x[BX_ESDI_DISK_STATS].n_value,
  2245.      sizeof (esdi_disk_stats));
  2246.  
  2247.   xswsrv_write (&esdi_disk_stats, sizeof (esdi_disk_stats));
  2248. }
  2249.  
  2250. /****************************************************************************
  2251.         get_wd_disk_data(g)
  2252. *****************************************************************************/
  2253. void
  2254. get_wd_disk_data (g)
  2255.      int             g;
  2256. {
  2257.  
  2258.   struct iotime   wd_disk_stats[4];
  2259.  
  2260.   kread ((caddr_t) & wd_disk_stats,
  2261.      x[BX_WD_DISK_STATS].n_value,
  2262.      sizeof (wd_disk_stats));
  2263.  
  2264.   xswsrv_write (&wd_disk_stats, sizeof (wd_disk_stats));
  2265. }
  2266.  
  2267.  
  2268. /****************************************************************************
  2269.     get_process_data(g)
  2270. *****************************************************************************/
  2271. void
  2272. get_process_data (g)
  2273.      int             g;
  2274. {
  2275.  
  2276.   struct proc    *begining_ps_proc_data_pointer = NULL;
  2277.   struct proc    *ps_proc_data_pointer = NULL;
  2278.  
  2279.   struct my_proc_struct *my_proc_data_pointer = NULL;
  2280.   struct my_proc_struct *begining_my_proc = NULL;
  2281.  
  2282.   struct user     tuser;
  2283.   struct my_user_struct *start_my_user = (struct my_user_struct *) 0;
  2284.   struct my_user_struct *my_user = (struct my_user_struct *) 0;
  2285.  
  2286.   int             i = 0;
  2287.   int             temp = 0;
  2288.   int             got_data;
  2289.   int             slots_in_use = 0;
  2290.  
  2291.   struct var     *var_data_pointer = NULL;
  2292.  
  2293.   var_data_pointer = (struct var *) malloc (sizeof (struct var));
  2294.  
  2295.   kread ((caddr_t) var_data_pointer,
  2296.      x[BX_V].n_value,
  2297.      sizeof (struct var));
  2298.  
  2299. /*
  2300.  * Get the number of slots in use in the process table, and only read
  2301.  * up to and including the last slot in use.....
  2302.  */
  2303.  
  2304.   slots_in_use = (unsigned) (var_data_pointer -> ve_proc -
  2305.                  x[BX_PROCS].n_value) / sizeof (struct proc);
  2306.  
  2307.  
  2308.  
  2309. /*
  2310.  * Get enough space to read in data....
  2311.  */
  2312.  
  2313.   ps_proc_data_pointer =
  2314.     (struct proc *) malloc (sizeof (struct proc) * slots_in_use);
  2315.  
  2316.   my_proc_data_pointer = (struct my_proc_struct *)
  2317.     malloc (sizeof (struct my_proc_struct) * slots_in_use);
  2318.  
  2319.   my_user = (struct my_user_struct *)
  2320.     malloc (sizeof (struct my_user_struct) * slots_in_use);
  2321.  
  2322. /*
  2323.  * Save the start of the pointers....
  2324.  */
  2325.  
  2326.  
  2327.   kread ((caddr_t) ps_proc_data_pointer,
  2328.      (daddr_t) x[BX_PROCS].n_value,
  2329.      sizeof (struct proc) * slots_in_use);
  2330.  
  2331.   begining_my_proc = my_proc_data_pointer;
  2332.   begining_ps_proc_data_pointer = ps_proc_data_pointer;
  2333.  
  2334.   start_my_user = my_user;
  2335.  
  2336.   for (i = 0; i < slots_in_use; i++)
  2337.     {
  2338.  
  2339.  
  2340. /*
  2341.  * If this slot is in use, then get the user data....
  2342.  */
  2343.  
  2344.       if (ps_proc_data_pointer -> p_stat)
  2345.     {
  2346.       temp = sysi86 (RDUBLK, ps_proc_data_pointer -> p_pid,
  2347.              (char *) &tuser, sizeof (struct user));
  2348.  
  2349.       if (temp != -1)
  2350.         {
  2351.           start_my_user -> p_pid = ps_proc_data_pointer -> p_pid;
  2352.           start_my_user -> u_tsize = tuser.u_tsize;
  2353.           start_my_user -> u_dsize = tuser.u_dsize;
  2354.           start_my_user -> u_ssize = tuser.u_ssize;
  2355.           start_my_user -> u_utime = tuser.u_utime;
  2356.           start_my_user -> u_stime = tuser.u_stime;
  2357.           strcpy (start_my_user -> u_psargs, tuser.u_psargs);
  2358.           strcpy (start_my_user -> u_comm, tuser.u_comm);
  2359.           start_my_user -> u_ior = abs (tuser.u_ior);
  2360.           start_my_user -> u_iow = abs (tuser.u_iow);
  2361.           start_my_user -> u_iosw = abs (tuser.u_iosw);
  2362.           start_my_user -> u_ioch = abs (tuser.u_ioch);
  2363.  
  2364.           start_my_user++;
  2365.         }
  2366.     }
  2367.  
  2368.       my_proc_data_pointer -> p_stat = ps_proc_data_pointer -> p_stat;
  2369.       my_proc_data_pointer -> p_pid = ps_proc_data_pointer -> p_pid;
  2370.       my_proc_data_pointer -> p_flag = ps_proc_data_pointer -> p_flag;
  2371.       my_proc_data_pointer -> p_usize = ps_proc_data_pointer -> p_usize;
  2372.       my_proc_data_pointer -> p_uid = ps_proc_data_pointer -> p_uid;
  2373.       my_proc_data_pointer -> p_suid = ps_proc_data_pointer -> p_suid;
  2374.       my_proc_data_pointer -> p_cpu = ps_proc_data_pointer -> p_cpu;
  2375.       my_proc_data_pointer -> p_pri = ps_proc_data_pointer -> p_pri;
  2376.       my_proc_data_pointer -> p_nice = ps_proc_data_pointer -> p_nice;
  2377.       my_proc_data_pointer -> p_pgrp = ps_proc_data_pointer -> p_pgrp;
  2378.  
  2379.       strncpy (my_proc_data_pointer -> tty,
  2380.            pgrp_to_ttyname (my_proc_data_pointer -> p_pgrp), 3);
  2381.  
  2382.       strncpy (my_proc_data_pointer -> name,
  2383.            uid_to_name (my_proc_data_pointer -> p_uid), 10);
  2384.  
  2385.       my_proc_data_pointer -> name[9] = '\0';
  2386.  
  2387.       my_proc_data_pointer++;
  2388.       ps_proc_data_pointer++;
  2389.     }
  2390.  
  2391. /*
  2392.  * Send  the last slot used....
  2393.  */
  2394.  
  2395.   xswsrv_write (&slots_in_use, sizeof (slots_in_use));
  2396.  
  2397.   xswsrv_read (&got_data, sizeof (int));
  2398.  
  2399. /*
  2400.  * Send  the process table up to and including the last slot used....
  2401.  */
  2402.  
  2403.   xswsrv_write (begining_my_proc,
  2404.         sizeof (struct my_proc_struct) * slots_in_use);
  2405.  
  2406.   xswsrv_read (&got_data, sizeof (int));
  2407.  
  2408. /*
  2409.  * Send  the user table per process....
  2410.  */
  2411.  
  2412.   xswsrv_write (my_user, sizeof (struct my_user_struct) * slots_in_use);
  2413.  
  2414.   free (begining_my_proc);
  2415.   free (begining_ps_proc_data_pointer);
  2416.   free (my_user);
  2417.   free (var_data_pointer);
  2418.  
  2419. }
  2420.  
  2421. // begin memory rework for 32v5 (5.0)
  2422. //
  2423.  
  2424. typedef struct _dbdcounts {  int none, swap, file, lstfile, 
  2425. swap_core, file_core, lstfile_core, zero, fill, proc;
  2426. } dbdinfo;
  2427.  
  2428. void prdbd(dbd_t dbd, pde_t pde, dbdinfo *d)
  2429. {
  2430.       switch (dbd.dbd_type)
  2431.     {
  2432.     case DBD_NONE:
  2433.       d->none++;
  2434.       break;
  2435.     case DBD_SWAP:
  2436.       d->swap++;
  2437.       if (pde.pgm.pg_pres)
  2438.         d->swap_core++;
  2439.       break;
  2440.     case DBD_DZERO:
  2441.       d->zero++;
  2442.       break;
  2443.     case DBD_FILE:
  2444.       d->file++;
  2445.       if (pde.pgm.pg_pres)
  2446.         d->file_core++;
  2447.       break;
  2448.     case DBD_DFILL:
  2449.       d->fill++;
  2450.       break;
  2451.     case DBD_PROC:
  2452.       d->proc++;
  2453.       break;
  2454.     default:
  2455.       break;
  2456.     }
  2457. }
  2458.  
  2459. static unsigned long pfdat = 0;
  2460. static struct mfmap mfmap[B_MAXARGS];
  2461. static int mfmax; 
  2462. int
  2463. pfntopfdix(uint pfn)
  2464. {
  2465.         register struct mfmap *mp;
  2466.  
  2467.         if (!pfdat) { 
  2468.         kread((caddr_t) &pfdat, x[BX_PFDAT].n_value, sizeof pfdat); 
  2469.         kread((caddr_t) &mfmap, x[BX_MFMAP].n_value, sizeof mfmap); 
  2470.         kread((caddr_t) &mfmax, x[BX_MFMAX].n_value, sizeof mfmax); 
  2471.     } 
  2472.         for (mp = &mfmap[mfmax-1]; mp >= mfmap; mp--)
  2473.                 if (mp->base <= pfn && pfn < mp->base + mp->extent)
  2474.                         return (mp->pf - (struct pfdat *)pfdat)
  2475.                                 + (pfn - mp->base);
  2476.         return -1;
  2477. }
  2478.  
  2479.  
  2480. void prpde(pde_t pde, dbdinfo *d)
  2481. {
  2482.         dbd_t dbd;
  2483.         int pfdix;
  2484.  
  2485.         if (pg_isvalid(&pde) || pde.pgd.dbd_type == DBD_PAGE) { /* L014 */
  2486.                 pfdix = pfntopfdix(pde.pgm.pg_pfn);
  2487.                 if (pfdix == -1) 
  2488.         {
  2489.                         *(uint*)&dbd = NV_NW_NONE;
  2490.                 }
  2491.                 else {
  2492.                       kread((caddr_t) &dbd, pfdat+pfdix*sizeof(struct pfdat),
  2493.                               sizeof dbd);
  2494.                 }
  2495.         }
  2496.         else {                                                  /* L014 v */
  2497.                 dbd = pde.pgd;
  2498.         }
  2499.         prdbd(dbd,pde,d);
  2500. }
  2501.  
  2502.  
  2503. void
  2504. eachpage( unsigned long   tab_addr, 
  2505.     int             count,
  2506.         int             all, 
  2507.     unsigned long   base, 
  2508.     int             first,
  2509.         int             shift, 
  2510.     const char      *head, 
  2511.     dbdinfo *d)
  2512. {
  2513.         int     i;
  2514.         pde_t   pde[NPGPT];
  2515.  
  2516.     // for some reason this must be mread not kread !!!
  2517.     mread((caddr_t) &pde, (unsigned long)tab_addr, sizeof (pde)); 
  2518.  
  2519.         for (i=first; count; i++, count--) {
  2520.                 if (i < 0 || i >= NPGPT) { 
  2521.                    fprintf(stderr,"%d out of range within MMU-table", i);
  2522.            break; 
  2523.            }
  2524.                 if (all || pg_isvalid(pde+i)                    /* L014 */
  2525.                 ||  pde[i].pgd.dbd_type == DBD_PAGE) {          /* L014 */
  2526.                         prpde(pde[i],d);
  2527.                 }
  2528.         }
  2529. }
  2530.  
  2531.  
  2532. // called once for each region 
  2533. // for each region, loop thru each page table
  2534. eachregion( long    *r_list, long    r_pgsz, long    r_segoff, dbdinfo *d) 
  2535. { 
  2536.     // read the pde from this region     
  2537.     long segoff, seglim, pglim, i, base=0;
  2538.     pde_t pde;
  2539.  
  2540.     base = - ctob(r_segoff);    /* so offsets shown start from zero */
  2541.         seglim = ctos((segoff = r_segoff) + r_pgsz);
  2542.  
  2543.         for (i = 0; i < seglim; segoff = 0, i++, r_list++) {
  2544.                 pglim = r_segoff + r_pgsz - stoc(i);
  2545.                 if (pglim > NPGPT)
  2546.                         pglim = NPGPT;
  2547.                 pglim -= segoff;
  2548.         
  2549.         // get the page table pointer
  2550.         kread((caddr_t) &pde, (daddr_t)r_list, sizeof(pde)); 
  2551.  
  2552.                 prpde(pde,d); 
  2553.                 if (pg_isvalid(&pde) ||  pde.pgd.dbd_type == DBD_PAGE) { 
  2554.             eachpage( ctob(pde.pgm.pg_pfn),
  2555.                          pglim, 1, base, segoff, PNUMSHFT, " OFFSET",d);
  2556.             } 
  2557.                 base += ctob(stoc(1));
  2558.         }
  2559.  
  2560. }
  2561. // called once for each proc 
  2562. // do a nested for loop: 
  2563. // for each region 
  2564. //
  2565. eachproc(struct proc *pp, 
  2566.     int *private_mem, 
  2567.     int *shared_mem, 
  2568.     int *weighted,
  2569.     int *virtual_size,
  2570.     dbdinfo *d
  2571.     )
  2572. { 
  2573.     struct pregion          pregbuf;
  2574.     struct region          rbuf;
  2575.     pregbuf.p_next = pp->p_region;
  2576.     while (pregbuf.p_next) {
  2577.         kread ((caddr_t) &pregbuf, pregbuf.p_next, sizeof pregbuf);  
  2578.         kread ((caddr_t) &rbuf, pregbuf.p_reg, sizeof rbuf); 
  2579.         if ( rbuf.r_refcnt!=0 && rbuf.r_pgsz && rbuf.r_list ) 
  2580.         { 
  2581.             eachregion((long *)rbuf.r_list,rbuf.r_pgsz,
  2582.                 rbuf.r_segoff, d); 
  2583.  
  2584.                   switch (rbuf.r_type) {
  2585.             case RT_UNUSED:
  2586.             case RT_MAPFILE:
  2587.             case RT_PRIVATE:
  2588.               *private_mem = *private_mem + rbuf.r_nvalid;
  2589.               break;
  2590.             case RT_STEXT:
  2591.             case RT_SHMEM:
  2592.             case RT_VM86:
  2593.               *shared_mem = *shared_mem + rbuf.r_nvalid;
  2594.               if (rbuf.r_refcnt != 0)
  2595.                 *weighted = *weighted + 
  2596.                 (rbuf.r_nvalid / rbuf.r_refcnt);
  2597.               break;
  2598.             default:
  2599.               break;
  2600.               /*
  2601.                * fprintf(stderr,"Got a hole in our logic!\n");
  2602.                */
  2603.             }
  2604.             *virtual_size = *virtual_size + rbuf.r_pgsz;
  2605.         }
  2606.     }
  2607. }
  2608. /****************************************************************************
  2609.     get_mem_process_data(g)
  2610. *****************************************************************************/
  2611. #ifndef RG_SWAP
  2612. #define RG_SWAP RG_SWAPOUT 
  2613. #endif
  2614.  
  2615. void
  2616. get_mem_process_data (g)
  2617.      int             g;
  2618. {
  2619.  
  2620.   register int    iproc;
  2621.  
  2622.   struct memory_usage *dynamic_memory_pointer = NULL;
  2623.   struct region   myregion;
  2624.   struct proc    *ps_proc_data_pointer = NULL;
  2625.   struct proc    *mytproc = NULL;
  2626.   struct proc   **pprocs = (struct proc **) 0;
  2627.   preg_t         *mypregion = NULL;
  2628.   preg_t         *start_mypregion = NULL;
  2629.   struct user     tuser;
  2630.   struct memory_usage current_process;
  2631.  
  2632.  
  2633.   int             noseg;
  2634.   unsigned        nopg;
  2635.   long           *dbd_addr;
  2636.   int             isstack;
  2637.   int             first;
  2638.   int             dbdfirst;
  2639.   int             k, l;
  2640.   dbd_t           dbd[NPGPT];
  2641.   pde_t           pde[NPGPT];
  2642.  
  2643.   int             dlist;
  2644.   int             list;
  2645.  
  2646.   dbdinfo d;
  2647.   #if 0
  2648.   int             none;
  2649.   int             swap;
  2650.   int             file;
  2651.   int             lstfile;
  2652.  
  2653.   int             swap_core;
  2654.   int             file_core;
  2655.   int             lstfile_core;
  2656.  
  2657.   int             zero;
  2658.   int             fill;
  2659.   int             iomap;
  2660.   int             window;
  2661. #endif
  2662.  
  2663.   int             current_mem_procs = 0;
  2664.   int             num_active_process = 0;
  2665.   int             num_regions = 0;
  2666.  
  2667.   int             virtual_size = 0;
  2668.   int             private_mem = 0;
  2669.   int             shared_mem = 0;
  2670.   int             weighted = 0;
  2671.  
  2672.   int             got_data = 0;
  2673.   int             slots_in_use = 0;
  2674.  
  2675.   int             j;
  2676.   int             temp;
  2677.   struct var     *var_data_pointer = NULL;
  2678.  
  2679.   var_data_pointer = (struct var *) malloc (sizeof (struct var));
  2680.  
  2681.   kread ((caddr_t) var_data_pointer,
  2682.      x[BX_V].n_value,
  2683.      sizeof (struct var));
  2684.  
  2685. /*
  2686.  * Get the number of slots in use in the process table, and only read
  2687.  * slots that are in use.....
  2688.  */
  2689.  
  2690.   slots_in_use = (unsigned) (var_data_pointer -> ve_proc -
  2691.                  x[BX_PROCS].n_value) / sizeof (struct proc);
  2692.  
  2693.  
  2694.   num_active_process = 0;
  2695.   current_mem_procs = 0;
  2696.  
  2697.  
  2698.   ps_proc_data_pointer =
  2699.     (struct proc *) malloc (sizeof (struct proc) * slots_in_use);
  2700.   pprocs = (struct proc **) malloc (sizeof (struct proc *) * slots_in_use);
  2701.  
  2702.  
  2703.   kread ((caddr_t) ps_proc_data_pointer, x[BX_PROCS].n_value,
  2704.      sizeof (struct proc) * slots_in_use);
  2705.  
  2706.   dynamic_memory_pointer =
  2707.     (struct memory_usage *) malloc (sizeof (struct memory_usage) * slots_in_use);
  2708.  
  2709.  
  2710.   for (iproc = 0; iproc < slots_in_use; iproc++)
  2711.     {
  2712.       
  2713.       virtual_size = 0;
  2714.       private_mem = 0;
  2715.       shared_mem = 0;
  2716.       weighted = 0;
  2717.       num_regions = 0;
  2718.  
  2719.       d.none = 0;
  2720.       d.swap = 0;
  2721.       d.file = 0;
  2722.       d.lstfile = 0;
  2723.       d.swap_core = 0;
  2724.       d.file_core = 0;
  2725.       d.lstfile_core = 0;
  2726.       d.zero = 0;
  2727.       d.fill = 0;
  2728.       d.proc = 0;
  2729.  
  2730.  
  2731.       mytproc = pprocs[iproc] = (ps_proc_data_pointer + iproc);
  2732.  
  2733.       if (mytproc -> p_stat)
  2734.     {
  2735.  
  2736.       num_active_process++;
  2737.  
  2738.       eachproc(mytproc, &private_mem, &shared_mem, 
  2739.               &weighted, &virtual_size, &d); 
  2740.  
  2741.       {
  2742.  
  2743.         temp = sysi86 (RDUBLK, mytproc -> p_pid,
  2744.                (char *) &tuser, sizeof (struct user));
  2745.  
  2746.         strncpy (current_process.name,
  2747.              uid_to_name (mytproc -> p_uid), 10);
  2748.  
  2749.         current_process.name[9] = '\0';
  2750.  
  2751.         current_process.p_pid = mytproc -> p_pid;
  2752.         current_process.p_suid = mytproc -> p_suid;
  2753.         current_process.p_uid = mytproc -> p_uid;
  2754.         current_process.virtual = virtual_size;
  2755.         current_process.private = private_mem;
  2756.         current_process.shared = shared_mem;
  2757.         current_process.weighted = weighted;
  2758.         current_process.total = private_mem + weighted;
  2759.         current_process.none = d.none;
  2760.         current_process.swap = d.swap;
  2761.         current_process.file = d.file;
  2762.         current_process.lstfile = d.lstfile;
  2763.         current_process.swap_core = d.swap_core;
  2764.         current_process.file_core = d.file_core;
  2765.         current_process.lstfile_core = d.lstfile_core;
  2766.         current_process.zero = d.zero;
  2767.         current_process.fill = d.fill;
  2768.         current_process.proc = d.proc;
  2769.  
  2770.         strcpy (current_process.u_psargs, tuser.u_psargs);
  2771.  
  2772.         dynamic_memory_pointer[current_mem_procs] = current_process;
  2773.  
  2774.         current_mem_procs++;
  2775.  
  2776.       }
  2777.  
  2778.     }
  2779.  
  2780.  
  2781.     }
  2782.  
  2783.   xswsrv_write (¤t_mem_procs, sizeof (int));
  2784.  
  2785.   xswsrv_read (&got_data, sizeof (int));
  2786.  
  2787.   xswsrv_write (dynamic_memory_pointer,
  2788.         sizeof (process_memory) * current_mem_procs);
  2789.  
  2790.   free (dynamic_memory_pointer);
  2791.   free (ps_proc_data_pointer);
  2792.   free (pprocs);
  2793.   free (var_data_pointer);
  2794.  
  2795. }
  2796.  
  2797. #ifdef kernel_swap_mem
  2798. /****************************************************************************
  2799.     get_kernel_read_data(g)
  2800. *****************************************************************************/
  2801. void
  2802. get_kernel_read_data (g)
  2803.      int             g;
  2804. {
  2805.  
  2806.   caddr_t        *addresse_data_pointer;
  2807.   struct netread *kernel_read_data_pointer;
  2808.  
  2809.   kernel_read_data_pointer = (struct netread *) malloc (sizeof (struct netread));
  2810.  
  2811.   xswsrv_read (kernel_read_data_pointer, sizeof (struct netread));
  2812.  
  2813.   addresse_data_pointer = (caddr_t *) malloc (kernel_read_data_pointer -> length);
  2814.  
  2815.   kread ((caddr_t) addresse_data_pointer,
  2816.      (daddr_t) kernel_read_data_pointer -> addresse,
  2817.      kernel_read_data_pointer -> length);
  2818.  
  2819.   xswsrv_write (addresse_data_pointer, kernel_read_data_pointer -> length);
  2820.  
  2821.   free (kernel_read_data_pointer);
  2822.   free (addresse_data_pointer);
  2823.  
  2824. }
  2825.  
  2826. /****************************************************************************
  2827.     get_mem_read_data(g)
  2828. *****************************************************************************/
  2829. void
  2830. get_mem_read_data (g)
  2831.      int             g;
  2832. {
  2833.   caddr_t        *addresse_data_pointer;
  2834.   struct netread *kernel_read_data_pointer;
  2835.  
  2836.   kernel_read_data_pointer = (struct netread *) malloc (sizeof (struct netread));
  2837.  
  2838.   xswsrv_read (kernel_read_data_pointer, sizeof (struct netread));
  2839.  
  2840.   addresse_data_pointer = (caddr_t *) malloc (kernel_read_data_pointer -> length);
  2841.  
  2842.   mread ((caddr_t) addresse_data_pointer,
  2843.      (daddr_t) kernel_read_data_pointer -> addresse,
  2844.      kernel_read_data_pointer -> length);
  2845.  
  2846.   xswsrv_write (addresse_data_pointer, kernel_read_data_pointer -> length);
  2847.  
  2848.   free (kernel_read_data_pointer);
  2849.   free (addresse_data_pointer);
  2850.  
  2851. }
  2852.  
  2853. /****************************************************************************
  2854.     get_swap_read_data(g)
  2855. *****************************************************************************/
  2856. void
  2857. get_swap_read_data (g)
  2858.      int             g;
  2859. {
  2860.   caddr_t        *addresse_data_pointer;
  2861.   struct netread *kernel_read_data_pointer;
  2862.  
  2863.   kernel_read_data_pointer = (struct netread *) malloc (sizeof (struct netread));
  2864.  
  2865.   xswsrv_read (kernel_read_data_pointer, sizeof (struct netread));
  2866.  
  2867.   addresse_data_pointer = (caddr_t *) malloc (kernel_read_data_pointer -> length);
  2868.  
  2869.   sread ((caddr_t) addresse_data_pointer,
  2870.      (daddr_t) kernel_read_data_pointer -> addresse,
  2871.      kernel_read_data_pointer -> length);
  2872.  
  2873.   xswsrv_write (addresse_data_pointer, kernel_read_data_pointer -> length);
  2874.  
  2875.   free (kernel_read_data_pointer);
  2876.   free (addresse_data_pointer);
  2877. }
  2878.  
  2879. #endif
  2880.  
  2881. #ifdef sysi86_stuff
  2882. /****************************************************************************
  2883.     get_sysi86_data(g)
  2884. *****************************************************************************/
  2885. void
  2886. get_sysi86_data (g)
  2887.      int             g;
  2888. {
  2889.   struct sysi86_struct *sysi86_command;
  2890.   char           *sysi86_data_pointer;
  2891.  
  2892.   sysi86_command = (struct sysi86_struct *) malloc (sizeof (struct sysi86_struct));
  2893.  
  2894.   xswsrv_read (sysi86_command, sizeof (struct sysi86_struct));
  2895.  
  2896.   sysi86_data_pointer = (char *) malloc (sysi86_command -> length);
  2897.  
  2898.   sysi86 (RDUBLK, sysi86_command -> pid, (char *) sysi86_data_pointer,
  2899.       sysi86_command -> length);
  2900.  
  2901.   xswsrv_write (sysi86_data_pointer, sysi86_command -> length);
  2902.  
  2903.   free (sysi86_data_pointer);
  2904.  
  2905. }
  2906.  
  2907. #endif
  2908.  
  2909. /****************************************************************************
  2910.     get_hz_data(g)
  2911. *****************************************************************************/
  2912. void
  2913. get_hz_data (g)
  2914.      int             g;
  2915. {
  2916.   int             hz_data_pointer;
  2917.  
  2918.   kread ((caddr_t) & hz_data_pointer,
  2919.      x[BX_HZ].n_value,
  2920.      sizeof (hz_data_pointer));
  2921.  
  2922.   xswsrv_write (&hz_data_pointer, sizeof (int));
  2923. }
  2924.  
  2925.  
  2926. /****************************************************************************
  2927.     quitting()
  2928. *****************************************************************************/
  2929. void
  2930. quitting ()
  2931. {
  2932.  
  2933.   int             status;
  2934.  
  2935.  
  2936. #ifdef TESTING
  2937.   gct_writelog (test_log);
  2938. #endif
  2939.  
  2940.   sleep (1);
  2941.  
  2942.   close (g);
  2943.  
  2944.   while (waitpid (0, &status, WNOHANG) > 0)
  2945.     ;
  2946.  
  2947.   _exit (0);
  2948. }
  2949.  
  2950. int
  2951. client_security_check ()
  2952.  
  2953. {
  2954.  
  2955.   char           *one_client;
  2956.   int             n;
  2957.   char           *space;
  2958.  
  2959.   char           *client_sysname;
  2960.   int             found_match = 0;
  2961.  
  2962.  
  2963.   client_sysname = (char *) malloc (sizeof (char) * 20);
  2964.   space = (char *) malloc (sizeof (char) * 2);
  2965.   strcpy (space, " ");
  2966.  
  2967.   if (found_client == 0)
  2968.     return (CLIENT_OK);
  2969.   else if (strlen (client_str) == 0)
  2970.     return (CLIENT_OK);
  2971.   else
  2972. /*
  2973.  * Looks like we get to parse the string for our client....
  2974.  */
  2975.  
  2976.  
  2977.     {
  2978.  
  2979.       strcpy (client_sysname, client_sysuts.sysname);
  2980.  
  2981.       one_client = strtok (client_str, space);
  2982.  
  2983.       if (strcmp (one_client, client_sysname) == 0)
  2984.     {
  2985.       found_match = 1;
  2986.     }
  2987.  
  2988.       while ((found_match == 0) &&
  2989.          (one_client = strtok (NULL, space)) != NULL)
  2990.  
  2991.     {
  2992.       if (strcmp (one_client, client_sysname) == 0)
  2993.         {
  2994.           found_match = 1;
  2995.         }
  2996.     }
  2997.  
  2998.     }
  2999.  
  3000.   free (client_sysname);
  3001.   free (space);
  3002.  
  3003.   if (found_match == 1)
  3004.     return (CLIENT_OK);
  3005.   else
  3006.     return (CLIENT_NOT_OK);
  3007.  
  3008. }
  3009.  
  3010. void
  3011. initialize_structures ()
  3012. {
  3013.  
  3014.  
  3015.   int             result = 0;
  3016.  
  3017.   utmps = (struct utmp *) calloc (utmps_size, sizeof (struct utmp));
  3018.  
  3019.   result = stat (utmp_file, &utmp_stat_old);
  3020.  
  3021. /*
  3022.   if (result != 0)
  3023.     fprintf (stdout, "stat of utmp file did not work.....\n");
  3024. */
  3025.  
  3026. }
  3027.  
  3028.  
  3029.  
  3030. void
  3031. do_work ()
  3032.  
  3033. {
  3034.  
  3035.   int             done = 0;
  3036.   int             ready = 99999;
  3037.  
  3038.   int             answer;
  3039.   int             got_permission;
  3040.   int             uname_size;
  3041.   int             result;
  3042.  
  3043.  
  3044.   initialize_var_data ();
  3045.  
  3046.  
  3047.  
  3048. /*
  3049.  * The client will determine if the server and client are compatible....
  3050.  */
  3051.  
  3052.   xswsrv_write (&sync_number, sizeof (int));
  3053.  
  3054.   xswsrv_read (&answer, sizeof (int));
  3055.  
  3056.   if (answer != send_continue)
  3057.     {
  3058.       quitting ();
  3059.  
  3060.     }
  3061. /*
  3062.  * Now lets get the name of the client to see if it is o.k. to continue...
  3063.  */
  3064.  
  3065.   else
  3066.     {
  3067.  
  3068.       xswsrv_read (&uname_size, sizeof (int));
  3069.  
  3070.       xswsrv_read (&client_sysuts, uname_size);
  3071.  
  3072.       result = client_security_check ();
  3073.  
  3074.       if (result == CLIENT_NOT_OK)
  3075.     {
  3076.       got_permission = CLIENT_NOT_OK;
  3077.       xswsrv_write (&got_permission, sizeof (int));
  3078.       quitting ();
  3079.  
  3080.     }
  3081.       else
  3082.     {
  3083.  
  3084.       got_permission = CLIENT_OK;
  3085.       xswsrv_write (&got_permission, sizeof (int));
  3086.  
  3087.       initialize_structures ();
  3088.  
  3089.  
  3090.       while (!done)
  3091.         {
  3092.  
  3093.  
  3094.           xswsrv_read (MyBuffer, sizeof (int));
  3095.  
  3096.           switch (*MyBuffer)
  3097.         {
  3098.  
  3099.         case send_user_data:
  3100.           get_user_data (g);
  3101.           break;
  3102.         case send_freemem_data:
  3103.           get_freemem_data (g);
  3104.           break;
  3105.         case send_availsmem_data:
  3106.           get_availsmem_data (g);
  3107.           break;
  3108.         case send_sysinfo_data:
  3109.           get_sysinfo_data (g);
  3110.           break;
  3111.         case send_minfo_data:
  3112.           get_minfo_data (g);
  3113.           break;
  3114.         case send_tune_data:
  3115.           get_tune_data (g);
  3116.           break;
  3117.         case send_var_data:
  3118.           get_var_data (g);
  3119.           break;
  3120.         case send_bootinfo_data:
  3121.           get_bootinfo_data (g);
  3122.           break;
  3123.         case send_bootstring_data:
  3124.           get_bootstring_data (g);
  3125.           break;
  3126.         case send_maxmem_data:
  3127.           get_maxmem_data (g);
  3128.           break;
  3129.         case send_nswap_data:
  3130.           get_nswap_data (g);
  3131.           break;
  3132.         case send_files_data:
  3133.           get_files_data (g);
  3134.           break;
  3135.         case send_inodes_data:
  3136.           get_inodes_data (g);
  3137.           break;
  3138.         case send_procs_data:
  3139.           get_procs_data (g);
  3140.           break;
  3141.         case send_regions_data:
  3142.           get_regions_data (g);
  3143.           break;
  3144.         case send_cblocks_data:
  3145.           get_cblocks_data (g);
  3146.           break;
  3147.         case send_call_data:
  3148.           get_call_data (g);
  3149.           break;
  3150.         case send_mount_data:
  3151.           get_mount_data (g);
  3152.           break;
  3153.         case send_streams_data:
  3154.           get_streams_data (g);
  3155.           break;
  3156.         case send_process_data:
  3157.           get_process_data (g);
  3158.           break;
  3159.         case send_mem_process_data:
  3160.           get_mem_process_data (g);
  3161.           break;
  3162. #ifdef kernel_swap_mem
  3163.         case send_kernel_read_data:
  3164.           get_kernel_read_data (g);
  3165.           break;
  3166.         case send_mem_read_data:
  3167.           get_mem_read_data (g);
  3168.           break;
  3169.         case send_swap_read_data:
  3170.           get_swap_read_data (g);
  3171.           break;
  3172. #endif
  3173. #ifdef sysi86_stuff
  3174.         case send_sysi86_user_data:
  3175.           get_sysi86_data (g);
  3176.           break;
  3177. #endif
  3178.         case send_hz_data:
  3179.           get_hz_data (g);
  3180.           break;
  3181.         case send_nfs_data:
  3182.           get_nfs_data (g);
  3183.           break;
  3184.         case send_nfs_available:
  3185.           get_nfs_available (g);
  3186.           break;
  3187.         case send_floppy_disk_available:
  3188.           get_floppy_disk_available (g);
  3189.           break;
  3190.         case send_scsi_disk_available:
  3191.           get_scsi_disk_available (g);
  3192.           break;
  3193.         case send_scsi_tape_available:
  3194.           get_scsi_tape_available (g);
  3195.           break;
  3196.         case send_scsi_rom_available:
  3197.           get_scsi_rom_available (g);
  3198.           break;
  3199.         case send_cart_tape_available:
  3200.           get_cart_tape_available (g);
  3201.           break;
  3202.         case send_esdi_disk_available:
  3203.           get_esdi_disk_available (g);
  3204.           break;
  3205.         case send_wd_disk_available:
  3206.           get_wd_disk_available (g);
  3207.           break;
  3208.         case send_floppy_disk_data:
  3209.           get_floppy_disk_data (g);
  3210.           break;
  3211.         case send_scsi_disk_data:
  3212.           get_scsi_disk_data (g);
  3213.           break;
  3214.         case send_scsi_tape_data:
  3215.           get_scsi_tape_data (g);
  3216.           break;
  3217.         case send_scsi_rom_data:
  3218.           get_scsi_rom_data (g);
  3219.           break;
  3220.         case send_cart_tape_data:
  3221.           get_cart_tape_data (g);
  3222.           break;
  3223.         case send_esdi_disk_data:
  3224.           get_esdi_disk_data (g);
  3225.           break;
  3226.         case send_wd_disk_data:
  3227.           get_wd_disk_data (g);
  3228.           break;
  3229.         case send_boot_time:
  3230.           get_boot_time (g);
  3231.           break;
  3232.         case send_disk_space_data:
  3233.           get_filesystem_space (g);
  3234.           break;
  3235.         case send_os_version_data:
  3236.           get_os_version_data(g);
  3237.           break;
  3238.  
  3239.         case send_quitting_data:
  3240.           quitting ();
  3241.           break;
  3242.  
  3243.         default:
  3244.           break;
  3245.  
  3246.         }        /* End of Case statement */
  3247.  
  3248.         }            /* End of  while (!done) statement */
  3249.     }
  3250.     }
  3251.  
  3252. }
  3253.  
  3254. terminate_session ()
  3255.  
  3256. {
  3257.   close (FileDescriptor);
  3258.   exit (0);
  3259. }
  3260.  
  3261.  
  3262. redo_general_initialization ()
  3263. {
  3264.  
  3265.   read_defaults_file ();
  3266.  
  3267. }
  3268.  
  3269. /*************************************************************************
  3270. RunProgram()
  3271. ***************************************************************************/
  3272. RunProgram ()
  3273. {
  3274.  
  3275.   int             i = 0;
  3276.   int             len = sizeof (struct sockaddr_in);
  3277.   int             status;
  3278.   int             socket_send_size = 0;
  3279.   int             socket_recieve_size = 0;
  3280.   int             sendbuff = 0;
  3281.   int             recievebuff = 0;
  3282.   int             optlen = 0;
  3283.   int             no_delay = 0;
  3284.   int             pid;
  3285.   int             temp;
  3286.   int             result;
  3287.  
  3288.   struct utsname  memuts;
  3289.   struct utsname  sysuts;
  3290.  
  3291. #define EINTR 4
  3292.  
  3293.  
  3294. /*
  3295.  * If we are not inetd initialized, Put ourselves in the background and
  3296.  * act as if we are a daemon....
  3297.  */
  3298.  
  3299. #ifndef DEBUG
  3300.  
  3301.   if (!inetd)
  3302.     {
  3303.       if (fork ())
  3304.     exit (0);
  3305.     }
  3306.  
  3307. #endif
  3308.  
  3309.  
  3310.  
  3311. /*
  3312.  * If we get killed, terminte the session properly....
  3313.  */
  3314.  
  3315.   setpgrp ();
  3316.  
  3317.   signal (SIGTERM, terminate_session);
  3318.   signal (SIGHUP, redo_general_initialization);
  3319.   signal (SIGINT, SIG_IGN);
  3320.   signal (SIGHUP, SIG_IGN);
  3321.   signal (SIGQUIT, SIG_IGN);
  3322.   signal (SIGCHLD, catch_child);
  3323.   signal (SIGALRM, catch_alarm);
  3324.  
  3325.   kinit (0);
  3326.   minit (0);
  3327.   sinit ();
  3328.  
  3329. #ifdef OLDWAY
  3330.  
  3331.   init_uid_name_hash ();
  3332.  
  3333. #endif
  3334.  
  3335.  
  3336.   if (nlist (kernel, x) == -1)
  3337.     {
  3338.       fprintf (stdout, "cant't open %s\n", kernel);
  3339. #ifdef TESTING
  3340.       gct_writelog (test_log);
  3341. #endif
  3342.       exit (5);
  3343.  
  3344.     }
  3345.  
  3346.   uname (&sysuts);
  3347.  
  3348.   kread ((caddr_t) & memuts, x[BX_UTSNAME].n_value,
  3349.      sizeof (struct utsname));
  3350.  
  3351.   if (memcmp ((char *) &sysuts, (char *) &memuts, sizeof (struct utsname)))
  3352.     {
  3353.       fprintf (stdout, "%s is not the booted system. Use \"-u\" option to specify the booted system.\n", kernel);
  3354.       exit (6);
  3355.     }
  3356.  
  3357.  
  3358.   MyBuffer = (int *) malloc (sizeof (int));
  3359.  
  3360. /*
  3361.  * inetd will do the listen for us, we should use stdin for reading and
  3362.  * writing.....
  3363.  */
  3364.  
  3365.   if (!inetd)
  3366.     {
  3367.  
  3368.  
  3369.       if (listen (FileDescriptor, 5) < 0)
  3370.     perror ("listen failed :");
  3371.  
  3372.  
  3373.       for (;;)
  3374.     {
  3375.  
  3376.       while (waitpid (0, &status, WNOHANG) > 0)
  3377.         ;
  3378.  
  3379.       g = accept (FileDescriptor, &From, &len);
  3380.  
  3381.       if (g < 0)
  3382.         {
  3383.           if (errno != EINTR)
  3384.         {
  3385.         }
  3386.           continue;
  3387.         }
  3388.  
  3389. #ifndef DEBUG
  3390.       if (fork () == 0)
  3391. #endif
  3392.         {
  3393.           close (FileDescriptor);
  3394.           do_work ();
  3395.         }            /* End of if (fork) statement  */
  3396.  
  3397.       close (g);
  3398.  
  3399.     }            /* End of for (;;) statement  */
  3400.     }
  3401.   else
  3402.     {
  3403.  
  3404. /*
  3405.  * Since we are inetd spwaned, read and write to stdin
  3406.  */
  3407.       g = 0;
  3408.       do_work ();
  3409.  
  3410.     }
  3411.  
  3412. }
  3413.